]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_gdi_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
added a test to check how exception handling works with Win32 SEH; corrected copyright
[wxWidgets.git] / wxPython / src / mac / _gdi_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 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 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1757 #define SWIG_From_short PyInt_FromLong
1758 /*@@*/
1759
1760
1761 SWIGINTERN int
1762 SWIG_AsVal_short(PyObject *obj, short *val)
1763 {
1764 const char* errmsg = val ? "short" : (char*)0;
1765 long v;
1766 if (SWIG_AsVal_long(obj, &v)) {
1767 if (SWIG_CheckLongInRange(v, SHRT_MIN, SHRT_MAX, errmsg)) {
1768 if (val) *val = (short)(v);
1769 return 1;
1770 } else {
1771 return 0;
1772 }
1773 } else {
1774 PyErr_Clear();
1775 }
1776 if (val) {
1777 SWIG_type_error(errmsg, obj);
1778 }
1779 return 0;
1780 }
1781
1782
1783 SWIGINTERNSHORT short
1784 SWIG_As_short(PyObject* obj)
1785 {
1786 short v;
1787 if (!SWIG_AsVal_short(obj, &v)) {
1788 /*
1789 this is needed to make valgrind/purify happier.
1790 */
1791 memset((void*)&v, 0, sizeof(short));
1792 }
1793 return v;
1794 }
1795
1796
1797 SWIGINTERNSHORT int
1798 SWIG_Check_short(PyObject* obj)
1799 {
1800 return SWIG_AsVal_short(obj, (short*)0);
1801 }
1802
1803
1804 #include <wx/image.h>
1805
1806 static char** ConvertListOfStrings(PyObject* listOfStrings) {
1807 char** cArray = NULL;
1808 int count;
1809
1810 if (!PyList_Check(listOfStrings)) {
1811 PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
1812 return NULL;
1813 }
1814 count = PyList_Size(listOfStrings);
1815 cArray = new char*[count];
1816
1817 for(int x=0; x<count; x++) {
1818 // TODO: Need some validation and error checking here
1819 cArray[x] = PyString_AsString(PyList_GET_ITEM(listOfStrings, x));
1820 }
1821 return cArray;
1822 }
1823
1824
1825 static wxBitmap *new_wxBitmap(PyObject *listOfStrings){
1826 char** cArray = NULL;
1827 wxBitmap* bmp;
1828
1829 cArray = ConvertListOfStrings(listOfStrings);
1830 if (! cArray)
1831 return NULL;
1832 bmp = new wxBitmap(cArray);
1833 delete [] cArray;
1834 return bmp;
1835 }
1836 static wxBitmap *new_wxBitmap(PyObject *bits,int width,int height,int depth=1){
1837 char* buf;
1838 int length;
1839 PyString_AsStringAndSize(bits, &buf, &length);
1840 return new wxBitmap(buf, width, height, depth);
1841 }
1842 static wxSize wxBitmap_GetSize(wxBitmap *self){
1843 wxSize size(self->GetWidth(), self->GetHeight());
1844 return size;
1845 }
1846 static void wxBitmap_SetMaskColour(wxBitmap *self,wxColour const &colour){
1847 wxMask *mask = new wxMask(*self, colour);
1848 self->SetMask(mask);
1849 }
1850 static void wxBitmap_SetSize(wxBitmap *self,wxSize const &size){
1851 self->SetWidth(size.x);
1852 self->SetHeight(size.y);
1853 }
1854 static bool wxBitmap___eq__(wxBitmap *self,wxBitmap const *other){ return other ? (*self == *other) : false; }
1855 static bool wxBitmap___ne__(wxBitmap *self,wxBitmap const *other){ return other ? (*self != *other) : true; }
1856 static wxMask *new_wxMask(wxBitmap const &bitmap,wxColour const &colour=wxNullColour){
1857 if ( !colour.Ok() )
1858 return new wxMask(bitmap, *wxBLACK);
1859 else
1860 return new wxMask(bitmap, colour);
1861 }
1862
1863 #include <wx/iconbndl.h>
1864
1865 static wxIcon *new_wxIcon(wxBitmap const &bmp){
1866 wxIcon* icon = new wxIcon();
1867 icon->CopyFromBitmap(bmp);
1868 return icon;
1869 }
1870 static wxIcon *new_wxIcon(PyObject *listOfStrings){
1871 char** cArray = NULL;
1872 wxIcon* icon;
1873
1874 cArray = ConvertListOfStrings(listOfStrings);
1875 if (! cArray)
1876 return NULL;
1877 icon = new wxIcon(cArray);
1878 delete [] cArray;
1879 return icon;
1880 }
1881 static wxIconLocation *new_wxIconLocation(wxString const *filename=&wxPyEmptyString,int num=0){
1882
1883
1884
1885 return new wxIconLocation(*filename);
1886
1887 }
1888 static void wxIconLocation_SetIndex(wxIconLocation *self,int num){
1889
1890
1891
1892 // do nothing
1893
1894 }
1895 static int wxIconLocation_GetIndex(wxIconLocation *self){
1896
1897
1898
1899 return -1;
1900
1901 }
1902
1903 SWIGINTERNSHORT long
1904 SWIG_As_long(PyObject* obj)
1905 {
1906 long v;
1907 if (!SWIG_AsVal_long(obj, &v)) {
1908 /*
1909 this is needed to make valgrind/purify happier.
1910 */
1911 memset((void*)&v, 0, sizeof(long));
1912 }
1913 return v;
1914 }
1915
1916
1917 SWIGINTERNSHORT int
1918 SWIG_Check_long(PyObject* obj)
1919 {
1920 return SWIG_AsVal_long(obj, (long*)0);
1921 }
1922
1923 static wxCursor *new_wxCursor(wxString const *cursorName,long type,int hotSpotX=0,int hotSpotY=0){
1924 #ifdef __WXGTK__
1925 wxCHECK_MSG(false, NULL,
1926 wxT("wx.Cursor constructor not implemented for wxGTK, use wx.StockCursor, wx.CursorFromImage, or wx.CursorFromBits instead."));
1927 #else
1928 return new wxCursor(*cursorName, type, hotSpotX, hotSpotY);
1929 #endif
1930 }
1931
1932
1933 static void wxRegionIterator_Next(wxRegionIterator *self){
1934 (*self) ++;
1935 }
1936 static bool wxRegionIterator___nonzero__(wxRegionIterator *self){
1937 return self->operator bool();
1938 }
1939
1940 #include <wx/fontutil.h>
1941 #include <wx/fontmap.h>
1942 #include <wx/fontenum.h>
1943
1944 static wxString wxNativeFontInfo___str__(wxNativeFontInfo *self){
1945 return self->ToString();
1946 }
1947
1948 wxNativeEncodingInfo* wxGetNativeFontEncoding(wxFontEncoding encoding) {
1949 static wxNativeEncodingInfo info;
1950 if ( wxGetNativeFontEncoding(encoding, &info) )
1951 return &info;
1952 else
1953 return NULL;
1954 }
1955
1956 static PyObject *wxFontMapper_GetAltForEncoding(wxFontMapper *self,wxFontEncoding encoding,wxString const &facename=wxPyEmptyString,bool interactive=true){
1957 wxFontEncoding alt_enc;
1958 if (self->GetAltForEncoding(encoding, &alt_enc, facename, interactive))
1959 return PyInt_FromLong(alt_enc);
1960 else {
1961 Py_INCREF(Py_None);
1962 return Py_None;
1963 }
1964 }
1965 static wxFont *new_wxFont(wxString const &info){
1966 wxNativeFontInfo nfi;
1967 nfi.FromString(info);
1968 return new wxFont(nfi);
1969 }
1970 static wxFont *new_wxFont(int pointSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxPyEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1971 return wxFont::New(pointSize, family, flags, face, encoding);
1972 }
1973 static wxFont *new_wxFont(wxSize const &pixelSize,int family,int style,int weight,bool underlined=false,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1974 return wxFontBase::New(pixelSize, family,
1975 style, weight, underlined,
1976 face, encoding);
1977 }
1978 static bool wxFont___eq__(wxFont *self,wxFont const *other){ return other ? (*self == *other) : false; }
1979 static bool wxFont___ne__(wxFont *self,wxFont const *other){ return other ? (*self != *other) : true; }
1980
1981 class wxPyFontEnumerator : public wxFontEnumerator {
1982 public:
1983 wxPyFontEnumerator() {}
1984 ~wxPyFontEnumerator() {}
1985
1986 DEC_PYCALLBACK_BOOL_STRING(OnFacename);
1987 DEC_PYCALLBACK_BOOL_STRINGSTRING(OnFontEncoding);
1988
1989 PYPRIVATE;
1990 };
1991
1992 IMP_PYCALLBACK_BOOL_STRING(wxPyFontEnumerator, wxFontEnumerator, OnFacename);
1993 IMP_PYCALLBACK_BOOL_STRINGSTRING(wxPyFontEnumerator, wxFontEnumerator, OnFontEncoding);
1994
1995
1996 static PyObject *wxPyFontEnumerator_GetEncodings(wxPyFontEnumerator *self){
1997 wxArrayString* arr = self->GetEncodings();
1998 if (arr)
1999 return wxArrayString2PyList_helper(*arr);
2000 else
2001 return PyList_New(0);
2002 }
2003 static PyObject *wxPyFontEnumerator_GetFacenames(wxPyFontEnumerator *self){
2004 wxArrayString* arr = self->GetFacenames();
2005 if (arr)
2006 return wxArrayString2PyList_helper(*arr);
2007 else
2008 return PyList_New(0);
2009 }
2010
2011 #include <locale.h>
2012
2013 static wxLocale *new_wxLocale(int language=-1,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
2014 wxLocale* loc;
2015 if (language == -1)
2016 loc = new wxLocale();
2017 else
2018 loc = new wxLocale(language, flags);
2019 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
2020 // for the floating point conversions and such to work right.
2021 #if PY_VERSION_HEX < 0x02040000
2022 setlocale(LC_NUMERIC, "C");
2023 #endif
2024 return loc;
2025 }
2026 static bool wxLocale_Init1(wxLocale *self,wxString const &szName,wxString const &szShort=wxPyEmptyString,wxString const &szLocale=wxPyEmptyString,bool bLoadDefault=true,bool bConvertEncoding=false){
2027 bool rc = self->Init(szName, szShort, szLocale, bLoadDefault, bConvertEncoding);
2028 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
2029 // for the floating point conversions and such to work right.
2030 #if PY_VERSION_HEX < 0x02040000
2031 setlocale(LC_NUMERIC, "C");
2032 #endif
2033 return rc;
2034 }
2035 static bool wxLocale_Init2(wxLocale *self,int language=wxLANGUAGE_DEFAULT,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
2036 bool rc = self->Init(language, flags);
2037 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
2038 // for the floating point conversions and such to work right.
2039 #if PY_VERSION_HEX < 0x02040000
2040 setlocale(LC_NUMERIC, "C");
2041 #endif
2042 return rc;
2043 }
2044
2045 #include "wx/wxPython/pydrawxxx.h"
2046
2047 static wxColour wxDC_GetPixel(wxDC *self,int x,int y){
2048 wxColour col;
2049 self->GetPixel(x, y, &col);
2050 return col;
2051 }
2052 static wxColour wxDC_GetPixelPoint(wxDC *self,wxPoint const &pt){
2053 wxColour col;
2054 self->GetPixel(pt, &col);
2055 return col;
2056 }
2057
2058 SWIGINTERN int
2059 SWIG_AsVal_double(PyObject *obj, double* val)
2060 {
2061 if (PyNumber_Check(obj)) {
2062 if (val) *val = PyFloat_AsDouble(obj);
2063 return 1;
2064 }
2065 else {
2066 SWIG_type_error("number", obj);
2067 }
2068 return 0;
2069 }
2070
2071
2072 SWIGINTERNSHORT double
2073 SWIG_As_double(PyObject* obj)
2074 {
2075 double v;
2076 if (!SWIG_AsVal_double(obj, &v)) {
2077 /*
2078 this is needed to make valgrind/purify happier.
2079 */
2080 memset((void*)&v, 0, sizeof(double));
2081 }
2082 return v;
2083 }
2084
2085
2086 SWIGINTERNSHORT int
2087 SWIG_Check_double(PyObject* obj)
2088 {
2089 return SWIG_AsVal_double(obj, (double*)0);
2090 }
2091
2092 static wxRect wxDC_DrawImageLabel(wxDC *self,wxString const &text,wxBitmap const &image,wxRect const &rect,int alignment=wxALIGN_LEFT|wxALIGN_TOP,int indexAccel=-1){
2093 wxRect rv;
2094 self->DrawLabel(text, image, rect, alignment, indexAccel, &rv);
2095 return rv;
2096 }
2097
2098 static wxRect wxDC_GetClippingRect(wxDC *self){
2099 wxRect rect;
2100 self->GetClippingBox(rect);
2101 return rect;
2102 }
2103 static wxArrayInt wxDC_GetPartialTextExtents(wxDC *self,wxString const &text){
2104 wxArrayInt widths;
2105 self->GetPartialTextExtents(text, widths);
2106 return widths;
2107 }
2108
2109 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2110 #define SWIG_From_double PyFloat_FromDouble
2111 /*@@*/
2112
2113
2114 static void wxDC_SetLogicalOriginPoint(wxDC *self,wxPoint const &point){
2115 self->SetLogicalOrigin(point.x, point.y);
2116 }
2117 static void wxDC_SetDeviceOriginPoint(wxDC *self,wxPoint const &point){
2118 self->SetDeviceOrigin(point.x, point.y);
2119 }
2120 static void wxDC_CalcBoundingBoxPoint(wxDC *self,wxPoint const &point){
2121 self->CalcBoundingBox(point.x, point.y);
2122 }
2123 static PyObject *wxDC__DrawPointList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2124 return wxPyDrawXXXList(*self, wxPyDrawXXXPoint, pyCoords, pyPens, pyBrushes);
2125 }
2126 static PyObject *wxDC__DrawLineList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2127 return wxPyDrawXXXList(*self, wxPyDrawXXXLine, pyCoords, pyPens, pyBrushes);
2128 }
2129 static PyObject *wxDC__DrawRectangleList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2130 return wxPyDrawXXXList(*self, wxPyDrawXXXRectangle, pyCoords, pyPens, pyBrushes);
2131 }
2132 static PyObject *wxDC__DrawEllipseList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2133 return wxPyDrawXXXList(*self, wxPyDrawXXXEllipse, pyCoords, pyPens, pyBrushes);
2134 }
2135 static PyObject *wxDC__DrawPolygonList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2136 return wxPyDrawXXXList(*self, wxPyDrawXXXPolygon, pyCoords, pyPens, pyBrushes);
2137 }
2138 static PyObject *wxDC__DrawTextList(wxDC *self,PyObject *textList,PyObject *pyPoints,PyObject *foregroundList,PyObject *backgroundList){
2139 return wxPyDrawTextList(*self, textList, pyPoints, foregroundList, backgroundList);
2140 }
2141
2142 static void wxDC_GetBoundingBox(wxDC* dc, int* x1, int* y1, int* x2, int* y2) {
2143 *x1 = dc->MinX();
2144 *y1 = dc->MinY();
2145 *x2 = dc->MaxX();
2146 *y2 = dc->MaxY();
2147 }
2148
2149
2150 #include <wx/dcbuffer.h>
2151
2152
2153 #include <wx/dcps.h>
2154
2155
2156 #include <wx/metafile.h>
2157
2158
2159
2160 static void wxColourDatabase_Append(wxColourDatabase *self,wxString const &name,int red,int green,int blue){
2161 self->AddColour(name, wxColour(red, green, blue));
2162 }
2163
2164 #include <wx/effects.h>
2165
2166 #ifdef __cplusplus
2167 extern "C" {
2168 #endif
2169 static PyObject *_wrap_new_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2170 PyObject *resultobj;
2171 wxGDIObject *result;
2172 char *kwnames[] = {
2173 NULL
2174 };
2175
2176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GDIObject",kwnames)) goto fail;
2177 {
2178 if (!wxPyCheckForApp()) SWIG_fail;
2179 PyThreadState* __tstate = wxPyBeginAllowThreads();
2180 result = (wxGDIObject *)new wxGDIObject();
2181
2182 wxPyEndAllowThreads(__tstate);
2183 if (PyErr_Occurred()) SWIG_fail;
2184 }
2185 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGDIObject, 1);
2186 return resultobj;
2187 fail:
2188 return NULL;
2189 }
2190
2191
2192 static PyObject *_wrap_delete_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2193 PyObject *resultobj;
2194 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2195 PyObject * obj0 = 0 ;
2196 char *kwnames[] = {
2197 (char *) "self", NULL
2198 };
2199
2200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GDIObject",kwnames,&obj0)) goto fail;
2201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2202 if (SWIG_arg_fail(1)) SWIG_fail;
2203 {
2204 PyThreadState* __tstate = wxPyBeginAllowThreads();
2205 delete arg1;
2206
2207 wxPyEndAllowThreads(__tstate);
2208 if (PyErr_Occurred()) SWIG_fail;
2209 }
2210 Py_INCREF(Py_None); resultobj = Py_None;
2211 return resultobj;
2212 fail:
2213 return NULL;
2214 }
2215
2216
2217 static PyObject *_wrap_GDIObject_GetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2218 PyObject *resultobj;
2219 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2220 bool result;
2221 PyObject * obj0 = 0 ;
2222 char *kwnames[] = {
2223 (char *) "self", NULL
2224 };
2225
2226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_GetVisible",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
2231 result = (bool)(arg1)->GetVisible();
2232
2233 wxPyEndAllowThreads(__tstate);
2234 if (PyErr_Occurred()) SWIG_fail;
2235 }
2236 {
2237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2238 }
2239 return resultobj;
2240 fail:
2241 return NULL;
2242 }
2243
2244
2245 static PyObject *_wrap_GDIObject_SetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2246 PyObject *resultobj;
2247 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2248 bool arg2 ;
2249 PyObject * obj0 = 0 ;
2250 PyObject * obj1 = 0 ;
2251 char *kwnames[] = {
2252 (char *) "self",(char *) "visible", NULL
2253 };
2254
2255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GDIObject_SetVisible",kwnames,&obj0,&obj1)) goto fail;
2256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2257 if (SWIG_arg_fail(1)) SWIG_fail;
2258 {
2259 arg2 = (bool)(SWIG_As_bool(obj1));
2260 if (SWIG_arg_fail(2)) SWIG_fail;
2261 }
2262 {
2263 PyThreadState* __tstate = wxPyBeginAllowThreads();
2264 (arg1)->SetVisible(arg2);
2265
2266 wxPyEndAllowThreads(__tstate);
2267 if (PyErr_Occurred()) SWIG_fail;
2268 }
2269 Py_INCREF(Py_None); resultobj = Py_None;
2270 return resultobj;
2271 fail:
2272 return NULL;
2273 }
2274
2275
2276 static PyObject *_wrap_GDIObject_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
2277 PyObject *resultobj;
2278 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2279 bool result;
2280 PyObject * obj0 = 0 ;
2281 char *kwnames[] = {
2282 (char *) "self", NULL
2283 };
2284
2285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_IsNull",kwnames,&obj0)) goto fail;
2286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2287 if (SWIG_arg_fail(1)) SWIG_fail;
2288 {
2289 PyThreadState* __tstate = wxPyBeginAllowThreads();
2290 result = (bool)(arg1)->IsNull();
2291
2292 wxPyEndAllowThreads(__tstate);
2293 if (PyErr_Occurred()) SWIG_fail;
2294 }
2295 {
2296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2297 }
2298 return resultobj;
2299 fail:
2300 return NULL;
2301 }
2302
2303
2304 static PyObject * GDIObject_swigregister(PyObject *, PyObject *args) {
2305 PyObject *obj;
2306 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2307 SWIG_TypeClientData(SWIGTYPE_p_wxGDIObject, obj);
2308 Py_INCREF(obj);
2309 return Py_BuildValue((char *)"");
2310 }
2311 static PyObject *_wrap_new_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2312 PyObject *resultobj;
2313 byte arg1 = (byte) 0 ;
2314 byte arg2 = (byte) 0 ;
2315 byte arg3 = (byte) 0 ;
2316 wxColour *result;
2317 PyObject * obj0 = 0 ;
2318 PyObject * obj1 = 0 ;
2319 PyObject * obj2 = 0 ;
2320 char *kwnames[] = {
2321 (char *) "red",(char *) "green",(char *) "blue", NULL
2322 };
2323
2324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Colour",kwnames,&obj0,&obj1,&obj2)) goto fail;
2325 if (obj0) {
2326 {
2327 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
2328 if (SWIG_arg_fail(1)) SWIG_fail;
2329 }
2330 }
2331 if (obj1) {
2332 {
2333 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2334 if (SWIG_arg_fail(2)) SWIG_fail;
2335 }
2336 }
2337 if (obj2) {
2338 {
2339 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2340 if (SWIG_arg_fail(3)) SWIG_fail;
2341 }
2342 }
2343 {
2344 PyThreadState* __tstate = wxPyBeginAllowThreads();
2345 result = (wxColour *)new wxColour(arg1,arg2,arg3);
2346
2347 wxPyEndAllowThreads(__tstate);
2348 if (PyErr_Occurred()) SWIG_fail;
2349 }
2350 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2351 return resultobj;
2352 fail:
2353 return NULL;
2354 }
2355
2356
2357 static PyObject *_wrap_new_NamedColour(PyObject *, PyObject *args, PyObject *kwargs) {
2358 PyObject *resultobj;
2359 wxString *arg1 = 0 ;
2360 wxColour *result;
2361 bool temp1 = false ;
2362 PyObject * obj0 = 0 ;
2363 char *kwnames[] = {
2364 (char *) "colorName", NULL
2365 };
2366
2367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_NamedColour",kwnames,&obj0)) goto fail;
2368 {
2369 arg1 = wxString_in_helper(obj0);
2370 if (arg1 == NULL) SWIG_fail;
2371 temp1 = true;
2372 }
2373 {
2374 if (!wxPyCheckForApp()) SWIG_fail;
2375 PyThreadState* __tstate = wxPyBeginAllowThreads();
2376 result = (wxColour *)new wxColour((wxString const &)*arg1);
2377
2378 wxPyEndAllowThreads(__tstate);
2379 if (PyErr_Occurred()) SWIG_fail;
2380 }
2381 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2382 {
2383 if (temp1)
2384 delete arg1;
2385 }
2386 return resultobj;
2387 fail:
2388 {
2389 if (temp1)
2390 delete arg1;
2391 }
2392 return NULL;
2393 }
2394
2395
2396 static PyObject *_wrap_new_ColourRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2397 PyObject *resultobj;
2398 unsigned long arg1 ;
2399 wxColour *result;
2400 PyObject * obj0 = 0 ;
2401 char *kwnames[] = {
2402 (char *) "colRGB", NULL
2403 };
2404
2405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ColourRGB",kwnames,&obj0)) goto fail;
2406 {
2407 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
2408 if (SWIG_arg_fail(1)) SWIG_fail;
2409 }
2410 {
2411 PyThreadState* __tstate = wxPyBeginAllowThreads();
2412 result = (wxColour *)new wxColour(arg1);
2413
2414 wxPyEndAllowThreads(__tstate);
2415 if (PyErr_Occurred()) SWIG_fail;
2416 }
2417 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2418 return resultobj;
2419 fail:
2420 return NULL;
2421 }
2422
2423
2424 static PyObject *_wrap_delete_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2425 PyObject *resultobj;
2426 wxColour *arg1 = (wxColour *) 0 ;
2427 PyObject * obj0 = 0 ;
2428 char *kwnames[] = {
2429 (char *) "self", NULL
2430 };
2431
2432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Colour",kwnames,&obj0)) goto fail;
2433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2434 if (SWIG_arg_fail(1)) SWIG_fail;
2435 {
2436 PyThreadState* __tstate = wxPyBeginAllowThreads();
2437 delete arg1;
2438
2439 wxPyEndAllowThreads(__tstate);
2440 if (PyErr_Occurred()) SWIG_fail;
2441 }
2442 Py_INCREF(Py_None); resultobj = Py_None;
2443 return resultobj;
2444 fail:
2445 return NULL;
2446 }
2447
2448
2449 static PyObject *_wrap_Colour_Red(PyObject *, PyObject *args, PyObject *kwargs) {
2450 PyObject *resultobj;
2451 wxColour *arg1 = (wxColour *) 0 ;
2452 byte result;
2453 PyObject * obj0 = 0 ;
2454 char *kwnames[] = {
2455 (char *) "self", NULL
2456 };
2457
2458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Red",kwnames,&obj0)) goto fail;
2459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2460 if (SWIG_arg_fail(1)) SWIG_fail;
2461 {
2462 PyThreadState* __tstate = wxPyBeginAllowThreads();
2463 result = (byte)(arg1)->Red();
2464
2465 wxPyEndAllowThreads(__tstate);
2466 if (PyErr_Occurred()) SWIG_fail;
2467 }
2468 {
2469 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2470 }
2471 return resultobj;
2472 fail:
2473 return NULL;
2474 }
2475
2476
2477 static PyObject *_wrap_Colour_Green(PyObject *, PyObject *args, PyObject *kwargs) {
2478 PyObject *resultobj;
2479 wxColour *arg1 = (wxColour *) 0 ;
2480 byte result;
2481 PyObject * obj0 = 0 ;
2482 char *kwnames[] = {
2483 (char *) "self", NULL
2484 };
2485
2486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Green",kwnames,&obj0)) goto fail;
2487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2488 if (SWIG_arg_fail(1)) SWIG_fail;
2489 {
2490 PyThreadState* __tstate = wxPyBeginAllowThreads();
2491 result = (byte)(arg1)->Green();
2492
2493 wxPyEndAllowThreads(__tstate);
2494 if (PyErr_Occurred()) SWIG_fail;
2495 }
2496 {
2497 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2498 }
2499 return resultobj;
2500 fail:
2501 return NULL;
2502 }
2503
2504
2505 static PyObject *_wrap_Colour_Blue(PyObject *, PyObject *args, PyObject *kwargs) {
2506 PyObject *resultobj;
2507 wxColour *arg1 = (wxColour *) 0 ;
2508 byte result;
2509 PyObject * obj0 = 0 ;
2510 char *kwnames[] = {
2511 (char *) "self", NULL
2512 };
2513
2514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Blue",kwnames,&obj0)) goto fail;
2515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2516 if (SWIG_arg_fail(1)) SWIG_fail;
2517 {
2518 PyThreadState* __tstate = wxPyBeginAllowThreads();
2519 result = (byte)(arg1)->Blue();
2520
2521 wxPyEndAllowThreads(__tstate);
2522 if (PyErr_Occurred()) SWIG_fail;
2523 }
2524 {
2525 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2526 }
2527 return resultobj;
2528 fail:
2529 return NULL;
2530 }
2531
2532
2533 static PyObject *_wrap_Colour_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
2534 PyObject *resultobj;
2535 wxColour *arg1 = (wxColour *) 0 ;
2536 bool result;
2537 PyObject * obj0 = 0 ;
2538 char *kwnames[] = {
2539 (char *) "self", NULL
2540 };
2541
2542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Ok",kwnames,&obj0)) goto fail;
2543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2544 if (SWIG_arg_fail(1)) SWIG_fail;
2545 {
2546 PyThreadState* __tstate = wxPyBeginAllowThreads();
2547 result = (bool)(arg1)->Ok();
2548
2549 wxPyEndAllowThreads(__tstate);
2550 if (PyErr_Occurred()) SWIG_fail;
2551 }
2552 {
2553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2554 }
2555 return resultobj;
2556 fail:
2557 return NULL;
2558 }
2559
2560
2561 static PyObject *_wrap_Colour_Set(PyObject *, PyObject *args, PyObject *kwargs) {
2562 PyObject *resultobj;
2563 wxColour *arg1 = (wxColour *) 0 ;
2564 byte arg2 ;
2565 byte arg3 ;
2566 byte arg4 ;
2567 PyObject * obj0 = 0 ;
2568 PyObject * obj1 = 0 ;
2569 PyObject * obj2 = 0 ;
2570 PyObject * obj3 = 0 ;
2571 char *kwnames[] = {
2572 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2573 };
2574
2575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Colour_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2577 if (SWIG_arg_fail(1)) SWIG_fail;
2578 {
2579 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2580 if (SWIG_arg_fail(2)) SWIG_fail;
2581 }
2582 {
2583 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2584 if (SWIG_arg_fail(3)) SWIG_fail;
2585 }
2586 {
2587 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2588 if (SWIG_arg_fail(4)) SWIG_fail;
2589 }
2590 {
2591 PyThreadState* __tstate = wxPyBeginAllowThreads();
2592 (arg1)->Set(arg2,arg3,arg4);
2593
2594 wxPyEndAllowThreads(__tstate);
2595 if (PyErr_Occurred()) SWIG_fail;
2596 }
2597 Py_INCREF(Py_None); resultobj = Py_None;
2598 return resultobj;
2599 fail:
2600 return NULL;
2601 }
2602
2603
2604 static PyObject *_wrap_Colour_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2605 PyObject *resultobj;
2606 wxColour *arg1 = (wxColour *) 0 ;
2607 unsigned long arg2 ;
2608 PyObject * obj0 = 0 ;
2609 PyObject * obj1 = 0 ;
2610 char *kwnames[] = {
2611 (char *) "self",(char *) "colRGB", NULL
2612 };
2613
2614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetRGB",kwnames,&obj0,&obj1)) goto fail;
2615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2616 if (SWIG_arg_fail(1)) SWIG_fail;
2617 {
2618 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
2619 if (SWIG_arg_fail(2)) SWIG_fail;
2620 }
2621 {
2622 PyThreadState* __tstate = wxPyBeginAllowThreads();
2623 (arg1)->Set(arg2);
2624
2625 wxPyEndAllowThreads(__tstate);
2626 if (PyErr_Occurred()) SWIG_fail;
2627 }
2628 Py_INCREF(Py_None); resultobj = Py_None;
2629 return resultobj;
2630 fail:
2631 return NULL;
2632 }
2633
2634
2635 static PyObject *_wrap_Colour_SetFromName(PyObject *, PyObject *args, PyObject *kwargs) {
2636 PyObject *resultobj;
2637 wxColour *arg1 = (wxColour *) 0 ;
2638 wxString *arg2 = 0 ;
2639 bool temp2 = false ;
2640 PyObject * obj0 = 0 ;
2641 PyObject * obj1 = 0 ;
2642 char *kwnames[] = {
2643 (char *) "self",(char *) "colourName", NULL
2644 };
2645
2646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetFromName",kwnames,&obj0,&obj1)) goto fail;
2647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2648 if (SWIG_arg_fail(1)) SWIG_fail;
2649 {
2650 arg2 = wxString_in_helper(obj1);
2651 if (arg2 == NULL) SWIG_fail;
2652 temp2 = true;
2653 }
2654 {
2655 PyThreadState* __tstate = wxPyBeginAllowThreads();
2656 (arg1)->InitFromName((wxString const &)*arg2);
2657
2658 wxPyEndAllowThreads(__tstate);
2659 if (PyErr_Occurred()) SWIG_fail;
2660 }
2661 Py_INCREF(Py_None); resultobj = Py_None;
2662 {
2663 if (temp2)
2664 delete arg2;
2665 }
2666 return resultobj;
2667 fail:
2668 {
2669 if (temp2)
2670 delete arg2;
2671 }
2672 return NULL;
2673 }
2674
2675
2676 static PyObject *_wrap_Colour_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2677 PyObject *resultobj;
2678 wxColour *arg1 = (wxColour *) 0 ;
2679 long result;
2680 PyObject * obj0 = 0 ;
2681 char *kwnames[] = {
2682 (char *) "self", NULL
2683 };
2684
2685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetPixel",kwnames,&obj0)) goto fail;
2686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2687 if (SWIG_arg_fail(1)) SWIG_fail;
2688 {
2689 PyThreadState* __tstate = wxPyBeginAllowThreads();
2690 result = (long)((wxColour const *)arg1)->GetPixel();
2691
2692 wxPyEndAllowThreads(__tstate);
2693 if (PyErr_Occurred()) SWIG_fail;
2694 }
2695 {
2696 resultobj = SWIG_From_long((long)(result));
2697 }
2698 return resultobj;
2699 fail:
2700 return NULL;
2701 }
2702
2703
2704 static PyObject *_wrap_Colour___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
2705 PyObject *resultobj;
2706 wxColour *arg1 = (wxColour *) 0 ;
2707 wxColour *arg2 = 0 ;
2708 bool result;
2709 wxColour temp2 ;
2710 PyObject * obj0 = 0 ;
2711 PyObject * obj1 = 0 ;
2712 char *kwnames[] = {
2713 (char *) "self",(char *) "colour", NULL
2714 };
2715
2716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___eq__",kwnames,&obj0,&obj1)) goto fail;
2717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2718 if (SWIG_arg_fail(1)) SWIG_fail;
2719 {
2720 arg2 = &temp2;
2721 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2722 }
2723 {
2724 PyThreadState* __tstate = wxPyBeginAllowThreads();
2725 result = (bool)((wxColour const *)arg1)->operator ==((wxColour const &)*arg2);
2726
2727 wxPyEndAllowThreads(__tstate);
2728 if (PyErr_Occurred()) SWIG_fail;
2729 }
2730 {
2731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2732 }
2733 return resultobj;
2734 fail:
2735 return NULL;
2736 }
2737
2738
2739 static PyObject *_wrap_Colour___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
2740 PyObject *resultobj;
2741 wxColour *arg1 = (wxColour *) 0 ;
2742 wxColour *arg2 = 0 ;
2743 bool result;
2744 wxColour temp2 ;
2745 PyObject * obj0 = 0 ;
2746 PyObject * obj1 = 0 ;
2747 char *kwnames[] = {
2748 (char *) "self",(char *) "colour", NULL
2749 };
2750
2751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___ne__",kwnames,&obj0,&obj1)) goto fail;
2752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2753 if (SWIG_arg_fail(1)) SWIG_fail;
2754 {
2755 arg2 = &temp2;
2756 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2757 }
2758 {
2759 PyThreadState* __tstate = wxPyBeginAllowThreads();
2760 result = (bool)((wxColour const *)arg1)->operator !=((wxColour const &)*arg2);
2761
2762 wxPyEndAllowThreads(__tstate);
2763 if (PyErr_Occurred()) SWIG_fail;
2764 }
2765 {
2766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2767 }
2768 return resultobj;
2769 fail:
2770 return NULL;
2771 }
2772
2773
2774 static PyObject *_wrap_Colour_Get(PyObject *, PyObject *args, PyObject *kwargs) {
2775 PyObject *resultobj;
2776 wxColour *arg1 = (wxColour *) 0 ;
2777 PyObject *result;
2778 PyObject * obj0 = 0 ;
2779 char *kwnames[] = {
2780 (char *) "self", NULL
2781 };
2782
2783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Get",kwnames,&obj0)) goto fail;
2784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2785 if (SWIG_arg_fail(1)) SWIG_fail;
2786 {
2787 PyThreadState* __tstate = wxPyBeginAllowThreads();
2788 result = (PyObject *)wxColour_Get(arg1);
2789
2790 wxPyEndAllowThreads(__tstate);
2791 if (PyErr_Occurred()) SWIG_fail;
2792 }
2793 resultobj = result;
2794 return resultobj;
2795 fail:
2796 return NULL;
2797 }
2798
2799
2800 static PyObject *_wrap_Colour_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2801 PyObject *resultobj;
2802 wxColour *arg1 = (wxColour *) 0 ;
2803 unsigned long result;
2804 PyObject * obj0 = 0 ;
2805 char *kwnames[] = {
2806 (char *) "self", NULL
2807 };
2808
2809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetRGB",kwnames,&obj0)) goto fail;
2810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2811 if (SWIG_arg_fail(1)) SWIG_fail;
2812 {
2813 PyThreadState* __tstate = wxPyBeginAllowThreads();
2814 result = (unsigned long)wxColour_GetRGB(arg1);
2815
2816 wxPyEndAllowThreads(__tstate);
2817 if (PyErr_Occurred()) SWIG_fail;
2818 }
2819 {
2820 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
2821 }
2822 return resultobj;
2823 fail:
2824 return NULL;
2825 }
2826
2827
2828 static PyObject * Colour_swigregister(PyObject *, PyObject *args) {
2829 PyObject *obj;
2830 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2831 SWIG_TypeClientData(SWIGTYPE_p_wxColour, obj);
2832 Py_INCREF(obj);
2833 return Py_BuildValue((char *)"");
2834 }
2835 static PyObject *_wrap_new_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2836 PyObject *resultobj;
2837 int arg1 ;
2838 unsigned char *arg2 = (unsigned char *) 0 ;
2839 unsigned char *arg3 = (unsigned char *) 0 ;
2840 unsigned char *arg4 = (unsigned char *) 0 ;
2841 wxPalette *result;
2842 PyObject * obj0 = 0 ;
2843 PyObject * obj1 = 0 ;
2844 PyObject * obj2 = 0 ;
2845 PyObject * obj3 = 0 ;
2846 char *kwnames[] = {
2847 (char *) "n",(char *) "red",(char *) "green",(char *) "blue", NULL
2848 };
2849
2850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_Palette",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2851 {
2852 arg1 = (int)(SWIG_As_int(obj0));
2853 if (SWIG_arg_fail(1)) SWIG_fail;
2854 }
2855 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2856 if (SWIG_arg_fail(2)) SWIG_fail;
2857 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2858 if (SWIG_arg_fail(3)) SWIG_fail;
2859 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2860 if (SWIG_arg_fail(4)) SWIG_fail;
2861 {
2862 if (!wxPyCheckForApp()) SWIG_fail;
2863 PyThreadState* __tstate = wxPyBeginAllowThreads();
2864 result = (wxPalette *)new wxPalette(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
2865
2866 wxPyEndAllowThreads(__tstate);
2867 if (PyErr_Occurred()) SWIG_fail;
2868 }
2869 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 1);
2870 return resultobj;
2871 fail:
2872 return NULL;
2873 }
2874
2875
2876 static PyObject *_wrap_delete_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2877 PyObject *resultobj;
2878 wxPalette *arg1 = (wxPalette *) 0 ;
2879 PyObject * obj0 = 0 ;
2880 char *kwnames[] = {
2881 (char *) "self", NULL
2882 };
2883
2884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Palette",kwnames,&obj0)) goto fail;
2885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2886 if (SWIG_arg_fail(1)) SWIG_fail;
2887 {
2888 PyThreadState* __tstate = wxPyBeginAllowThreads();
2889 delete arg1;
2890
2891 wxPyEndAllowThreads(__tstate);
2892 if (PyErr_Occurred()) SWIG_fail;
2893 }
2894 Py_INCREF(Py_None); resultobj = Py_None;
2895 return resultobj;
2896 fail:
2897 return NULL;
2898 }
2899
2900
2901 static PyObject *_wrap_Palette_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2902 PyObject *resultobj;
2903 wxPalette *arg1 = (wxPalette *) 0 ;
2904 byte arg2 ;
2905 byte arg3 ;
2906 byte arg4 ;
2907 int result;
2908 PyObject * obj0 = 0 ;
2909 PyObject * obj1 = 0 ;
2910 PyObject * obj2 = 0 ;
2911 PyObject * obj3 = 0 ;
2912 char *kwnames[] = {
2913 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2914 };
2915
2916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Palette_GetPixel",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2918 if (SWIG_arg_fail(1)) SWIG_fail;
2919 {
2920 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2921 if (SWIG_arg_fail(2)) SWIG_fail;
2922 }
2923 {
2924 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2925 if (SWIG_arg_fail(3)) SWIG_fail;
2926 }
2927 {
2928 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2929 if (SWIG_arg_fail(4)) SWIG_fail;
2930 }
2931 {
2932 PyThreadState* __tstate = wxPyBeginAllowThreads();
2933 result = (int)(arg1)->GetPixel(arg2,arg3,arg4);
2934
2935 wxPyEndAllowThreads(__tstate);
2936 if (PyErr_Occurred()) SWIG_fail;
2937 }
2938 {
2939 resultobj = SWIG_From_int((int)(result));
2940 }
2941 return resultobj;
2942 fail:
2943 return NULL;
2944 }
2945
2946
2947 static PyObject *_wrap_Palette_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2948 PyObject *resultobj;
2949 wxPalette *arg1 = (wxPalette *) 0 ;
2950 int arg2 ;
2951 byte *arg3 = (byte *) 0 ;
2952 byte *arg4 = (byte *) 0 ;
2953 byte *arg5 = (byte *) 0 ;
2954 bool result;
2955 byte temp3 ;
2956 int res3 = 0 ;
2957 byte temp4 ;
2958 int res4 = 0 ;
2959 byte temp5 ;
2960 int res5 = 0 ;
2961 PyObject * obj0 = 0 ;
2962 PyObject * obj1 = 0 ;
2963 char *kwnames[] = {
2964 (char *) "self",(char *) "pixel", NULL
2965 };
2966
2967 arg3 = &temp3; res3 = SWIG_NEWOBJ;
2968 arg4 = &temp4; res4 = SWIG_NEWOBJ;
2969 arg5 = &temp5; res5 = SWIG_NEWOBJ;
2970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Palette_GetRGB",kwnames,&obj0,&obj1)) goto fail;
2971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2972 if (SWIG_arg_fail(1)) SWIG_fail;
2973 {
2974 arg2 = (int)(SWIG_As_int(obj1));
2975 if (SWIG_arg_fail(2)) SWIG_fail;
2976 }
2977 {
2978 PyThreadState* __tstate = wxPyBeginAllowThreads();
2979 result = (bool)(arg1)->GetRGB(arg2,arg3,arg4,arg5);
2980
2981 wxPyEndAllowThreads(__tstate);
2982 if (PyErr_Occurred()) SWIG_fail;
2983 }
2984 {
2985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2986 }
2987 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
2988 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
2989 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
2990 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
2991 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
2992 SWIG_From_unsigned_SS_char((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_unsigned_char, 0)));
2993 return resultobj;
2994 fail:
2995 return NULL;
2996 }
2997
2998
2999 static PyObject *_wrap_Palette_GetColoursCount(PyObject *, PyObject *args, PyObject *kwargs) {
3000 PyObject *resultobj;
3001 wxPalette *arg1 = (wxPalette *) 0 ;
3002 int result;
3003 PyObject * obj0 = 0 ;
3004 char *kwnames[] = {
3005 (char *) "self", NULL
3006 };
3007
3008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_GetColoursCount",kwnames,&obj0)) goto fail;
3009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
3010 if (SWIG_arg_fail(1)) SWIG_fail;
3011 {
3012 PyThreadState* __tstate = wxPyBeginAllowThreads();
3013 result = (int)((wxPalette const *)arg1)->GetColoursCount();
3014
3015 wxPyEndAllowThreads(__tstate);
3016 if (PyErr_Occurred()) SWIG_fail;
3017 }
3018 {
3019 resultobj = SWIG_From_int((int)(result));
3020 }
3021 return resultobj;
3022 fail:
3023 return NULL;
3024 }
3025
3026
3027 static PyObject *_wrap_Palette_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3028 PyObject *resultobj;
3029 wxPalette *arg1 = (wxPalette *) 0 ;
3030 bool result;
3031 PyObject * obj0 = 0 ;
3032 char *kwnames[] = {
3033 (char *) "self", NULL
3034 };
3035
3036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_Ok",kwnames,&obj0)) goto fail;
3037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
3038 if (SWIG_arg_fail(1)) SWIG_fail;
3039 {
3040 PyThreadState* __tstate = wxPyBeginAllowThreads();
3041 result = (bool)(arg1)->Ok();
3042
3043 wxPyEndAllowThreads(__tstate);
3044 if (PyErr_Occurred()) SWIG_fail;
3045 }
3046 {
3047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3048 }
3049 return resultobj;
3050 fail:
3051 return NULL;
3052 }
3053
3054
3055 static PyObject * Palette_swigregister(PyObject *, PyObject *args) {
3056 PyObject *obj;
3057 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3058 SWIG_TypeClientData(SWIGTYPE_p_wxPalette, obj);
3059 Py_INCREF(obj);
3060 return Py_BuildValue((char *)"");
3061 }
3062 static PyObject *_wrap_new_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3063 PyObject *resultobj;
3064 wxColour *arg1 = 0 ;
3065 int arg2 = (int) 1 ;
3066 int arg3 = (int) wxSOLID ;
3067 wxPen *result;
3068 wxColour temp1 ;
3069 PyObject * obj0 = 0 ;
3070 PyObject * obj1 = 0 ;
3071 PyObject * obj2 = 0 ;
3072 char *kwnames[] = {
3073 (char *) "colour",(char *) "width",(char *) "style", NULL
3074 };
3075
3076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Pen",kwnames,&obj0,&obj1,&obj2)) goto fail;
3077 {
3078 arg1 = &temp1;
3079 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3080 }
3081 if (obj1) {
3082 {
3083 arg2 = (int)(SWIG_As_int(obj1));
3084 if (SWIG_arg_fail(2)) SWIG_fail;
3085 }
3086 }
3087 if (obj2) {
3088 {
3089 arg3 = (int)(SWIG_As_int(obj2));
3090 if (SWIG_arg_fail(3)) SWIG_fail;
3091 }
3092 }
3093 {
3094 if (!wxPyCheckForApp()) SWIG_fail;
3095 PyThreadState* __tstate = wxPyBeginAllowThreads();
3096 result = (wxPen *)new wxPen(*arg1,arg2,arg3);
3097
3098 wxPyEndAllowThreads(__tstate);
3099 if (PyErr_Occurred()) SWIG_fail;
3100 }
3101 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 1);
3102 return resultobj;
3103 fail:
3104 return NULL;
3105 }
3106
3107
3108 static PyObject *_wrap_delete_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3109 PyObject *resultobj;
3110 wxPen *arg1 = (wxPen *) 0 ;
3111 PyObject * obj0 = 0 ;
3112 char *kwnames[] = {
3113 (char *) "self", NULL
3114 };
3115
3116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Pen",kwnames,&obj0)) goto fail;
3117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3118 if (SWIG_arg_fail(1)) SWIG_fail;
3119 {
3120 PyThreadState* __tstate = wxPyBeginAllowThreads();
3121 delete arg1;
3122
3123 wxPyEndAllowThreads(__tstate);
3124 if (PyErr_Occurred()) SWIG_fail;
3125 }
3126 Py_INCREF(Py_None); resultobj = Py_None;
3127 return resultobj;
3128 fail:
3129 return NULL;
3130 }
3131
3132
3133 static PyObject *_wrap_Pen_GetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3134 PyObject *resultobj;
3135 wxPen *arg1 = (wxPen *) 0 ;
3136 int result;
3137 PyObject * obj0 = 0 ;
3138 char *kwnames[] = {
3139 (char *) "self", NULL
3140 };
3141
3142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetCap",kwnames,&obj0)) goto fail;
3143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3144 if (SWIG_arg_fail(1)) SWIG_fail;
3145 {
3146 PyThreadState* __tstate = wxPyBeginAllowThreads();
3147 result = (int)(arg1)->GetCap();
3148
3149 wxPyEndAllowThreads(__tstate);
3150 if (PyErr_Occurred()) SWIG_fail;
3151 }
3152 {
3153 resultobj = SWIG_From_int((int)(result));
3154 }
3155 return resultobj;
3156 fail:
3157 return NULL;
3158 }
3159
3160
3161 static PyObject *_wrap_Pen_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3162 PyObject *resultobj;
3163 wxPen *arg1 = (wxPen *) 0 ;
3164 wxColour result;
3165 PyObject * obj0 = 0 ;
3166 char *kwnames[] = {
3167 (char *) "self", NULL
3168 };
3169
3170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetColour",kwnames,&obj0)) goto fail;
3171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3172 if (SWIG_arg_fail(1)) SWIG_fail;
3173 {
3174 PyThreadState* __tstate = wxPyBeginAllowThreads();
3175 result = (arg1)->GetColour();
3176
3177 wxPyEndAllowThreads(__tstate);
3178 if (PyErr_Occurred()) SWIG_fail;
3179 }
3180 {
3181 wxColour * resultptr;
3182 resultptr = new wxColour((wxColour &)(result));
3183 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3184 }
3185 return resultobj;
3186 fail:
3187 return NULL;
3188 }
3189
3190
3191 static PyObject *_wrap_Pen_GetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3192 PyObject *resultobj;
3193 wxPen *arg1 = (wxPen *) 0 ;
3194 int result;
3195 PyObject * obj0 = 0 ;
3196 char *kwnames[] = {
3197 (char *) "self", NULL
3198 };
3199
3200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetJoin",kwnames,&obj0)) goto fail;
3201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3202 if (SWIG_arg_fail(1)) SWIG_fail;
3203 {
3204 PyThreadState* __tstate = wxPyBeginAllowThreads();
3205 result = (int)(arg1)->GetJoin();
3206
3207 wxPyEndAllowThreads(__tstate);
3208 if (PyErr_Occurred()) SWIG_fail;
3209 }
3210 {
3211 resultobj = SWIG_From_int((int)(result));
3212 }
3213 return resultobj;
3214 fail:
3215 return NULL;
3216 }
3217
3218
3219 static PyObject *_wrap_Pen_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3220 PyObject *resultobj;
3221 wxPen *arg1 = (wxPen *) 0 ;
3222 int result;
3223 PyObject * obj0 = 0 ;
3224 char *kwnames[] = {
3225 (char *) "self", NULL
3226 };
3227
3228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetStyle",kwnames,&obj0)) goto fail;
3229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3230 if (SWIG_arg_fail(1)) SWIG_fail;
3231 {
3232 PyThreadState* __tstate = wxPyBeginAllowThreads();
3233 result = (int)(arg1)->GetStyle();
3234
3235 wxPyEndAllowThreads(__tstate);
3236 if (PyErr_Occurred()) SWIG_fail;
3237 }
3238 {
3239 resultobj = SWIG_From_int((int)(result));
3240 }
3241 return resultobj;
3242 fail:
3243 return NULL;
3244 }
3245
3246
3247 static PyObject *_wrap_Pen_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3248 PyObject *resultobj;
3249 wxPen *arg1 = (wxPen *) 0 ;
3250 int result;
3251 PyObject * obj0 = 0 ;
3252 char *kwnames[] = {
3253 (char *) "self", NULL
3254 };
3255
3256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetWidth",kwnames,&obj0)) goto fail;
3257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3258 if (SWIG_arg_fail(1)) SWIG_fail;
3259 {
3260 PyThreadState* __tstate = wxPyBeginAllowThreads();
3261 result = (int)(arg1)->GetWidth();
3262
3263 wxPyEndAllowThreads(__tstate);
3264 if (PyErr_Occurred()) SWIG_fail;
3265 }
3266 {
3267 resultobj = SWIG_From_int((int)(result));
3268 }
3269 return resultobj;
3270 fail:
3271 return NULL;
3272 }
3273
3274
3275 static PyObject *_wrap_Pen_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3276 PyObject *resultobj;
3277 wxPen *arg1 = (wxPen *) 0 ;
3278 bool result;
3279 PyObject * obj0 = 0 ;
3280 char *kwnames[] = {
3281 (char *) "self", NULL
3282 };
3283
3284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_Ok",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
3289 result = (bool)(arg1)->Ok();
3290
3291 wxPyEndAllowThreads(__tstate);
3292 if (PyErr_Occurred()) SWIG_fail;
3293 }
3294 {
3295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3296 }
3297 return resultobj;
3298 fail:
3299 return NULL;
3300 }
3301
3302
3303 static PyObject *_wrap_Pen_SetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3304 PyObject *resultobj;
3305 wxPen *arg1 = (wxPen *) 0 ;
3306 int arg2 ;
3307 PyObject * obj0 = 0 ;
3308 PyObject * obj1 = 0 ;
3309 char *kwnames[] = {
3310 (char *) "self",(char *) "cap_style", NULL
3311 };
3312
3313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetCap",kwnames,&obj0,&obj1)) goto fail;
3314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3315 if (SWIG_arg_fail(1)) SWIG_fail;
3316 {
3317 arg2 = (int)(SWIG_As_int(obj1));
3318 if (SWIG_arg_fail(2)) SWIG_fail;
3319 }
3320 {
3321 PyThreadState* __tstate = wxPyBeginAllowThreads();
3322 (arg1)->SetCap(arg2);
3323
3324 wxPyEndAllowThreads(__tstate);
3325 if (PyErr_Occurred()) SWIG_fail;
3326 }
3327 Py_INCREF(Py_None); resultobj = Py_None;
3328 return resultobj;
3329 fail:
3330 return NULL;
3331 }
3332
3333
3334 static PyObject *_wrap_Pen_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3335 PyObject *resultobj;
3336 wxPen *arg1 = (wxPen *) 0 ;
3337 wxColour *arg2 = 0 ;
3338 wxColour temp2 ;
3339 PyObject * obj0 = 0 ;
3340 PyObject * obj1 = 0 ;
3341 char *kwnames[] = {
3342 (char *) "self",(char *) "colour", NULL
3343 };
3344
3345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetColour",kwnames,&obj0,&obj1)) goto fail;
3346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3347 if (SWIG_arg_fail(1)) SWIG_fail;
3348 {
3349 arg2 = &temp2;
3350 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3351 }
3352 {
3353 PyThreadState* __tstate = wxPyBeginAllowThreads();
3354 (arg1)->SetColour(*arg2);
3355
3356 wxPyEndAllowThreads(__tstate);
3357 if (PyErr_Occurred()) SWIG_fail;
3358 }
3359 Py_INCREF(Py_None); resultobj = Py_None;
3360 return resultobj;
3361 fail:
3362 return NULL;
3363 }
3364
3365
3366 static PyObject *_wrap_Pen_SetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3367 PyObject *resultobj;
3368 wxPen *arg1 = (wxPen *) 0 ;
3369 int arg2 ;
3370 PyObject * obj0 = 0 ;
3371 PyObject * obj1 = 0 ;
3372 char *kwnames[] = {
3373 (char *) "self",(char *) "join_style", NULL
3374 };
3375
3376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetJoin",kwnames,&obj0,&obj1)) goto fail;
3377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3378 if (SWIG_arg_fail(1)) SWIG_fail;
3379 {
3380 arg2 = (int)(SWIG_As_int(obj1));
3381 if (SWIG_arg_fail(2)) SWIG_fail;
3382 }
3383 {
3384 PyThreadState* __tstate = wxPyBeginAllowThreads();
3385 (arg1)->SetJoin(arg2);
3386
3387 wxPyEndAllowThreads(__tstate);
3388 if (PyErr_Occurred()) SWIG_fail;
3389 }
3390 Py_INCREF(Py_None); resultobj = Py_None;
3391 return resultobj;
3392 fail:
3393 return NULL;
3394 }
3395
3396
3397 static PyObject *_wrap_Pen_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3398 PyObject *resultobj;
3399 wxPen *arg1 = (wxPen *) 0 ;
3400 int arg2 ;
3401 PyObject * obj0 = 0 ;
3402 PyObject * obj1 = 0 ;
3403 char *kwnames[] = {
3404 (char *) "self",(char *) "style", NULL
3405 };
3406
3407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3409 if (SWIG_arg_fail(1)) SWIG_fail;
3410 {
3411 arg2 = (int)(SWIG_As_int(obj1));
3412 if (SWIG_arg_fail(2)) SWIG_fail;
3413 }
3414 {
3415 PyThreadState* __tstate = wxPyBeginAllowThreads();
3416 (arg1)->SetStyle(arg2);
3417
3418 wxPyEndAllowThreads(__tstate);
3419 if (PyErr_Occurred()) SWIG_fail;
3420 }
3421 Py_INCREF(Py_None); resultobj = Py_None;
3422 return resultobj;
3423 fail:
3424 return NULL;
3425 }
3426
3427
3428 static PyObject *_wrap_Pen_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3429 PyObject *resultobj;
3430 wxPen *arg1 = (wxPen *) 0 ;
3431 int arg2 ;
3432 PyObject * obj0 = 0 ;
3433 PyObject * obj1 = 0 ;
3434 char *kwnames[] = {
3435 (char *) "self",(char *) "width", NULL
3436 };
3437
3438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3440 if (SWIG_arg_fail(1)) SWIG_fail;
3441 {
3442 arg2 = (int)(SWIG_As_int(obj1));
3443 if (SWIG_arg_fail(2)) SWIG_fail;
3444 }
3445 {
3446 PyThreadState* __tstate = wxPyBeginAllowThreads();
3447 (arg1)->SetWidth(arg2);
3448
3449 wxPyEndAllowThreads(__tstate);
3450 if (PyErr_Occurred()) SWIG_fail;
3451 }
3452 Py_INCREF(Py_None); resultobj = Py_None;
3453 return resultobj;
3454 fail:
3455 return NULL;
3456 }
3457
3458
3459 static PyObject *_wrap_Pen_SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3460 PyObject *resultobj;
3461 wxPen *arg1 = (wxPen *) 0 ;
3462 int arg2 ;
3463 wxDash *arg3 = (wxDash *) 0 ;
3464 PyObject * obj0 = 0 ;
3465 PyObject * obj1 = 0 ;
3466 char *kwnames[] = {
3467 (char *) "self",(char *) "dashes", NULL
3468 };
3469
3470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetDashes",kwnames,&obj0,&obj1)) goto fail;
3471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3472 if (SWIG_arg_fail(1)) SWIG_fail;
3473 {
3474 arg2 = PyList_Size(obj1);
3475 arg3 = (wxDash*)byte_LIST_helper(obj1);
3476 if (arg3 == NULL) SWIG_fail;
3477 }
3478 {
3479 PyThreadState* __tstate = wxPyBeginAllowThreads();
3480 (arg1)->SetDashes(arg2,arg3);
3481
3482 wxPyEndAllowThreads(__tstate);
3483 if (PyErr_Occurred()) SWIG_fail;
3484 }
3485 Py_INCREF(Py_None); resultobj = Py_None;
3486 {
3487 if (arg3) delete [] arg3;
3488 }
3489 return resultobj;
3490 fail:
3491 {
3492 if (arg3) delete [] arg3;
3493 }
3494 return NULL;
3495 }
3496
3497
3498 static PyObject *_wrap_Pen_GetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3499 PyObject *resultobj;
3500 wxPen *arg1 = (wxPen *) 0 ;
3501 PyObject *result;
3502 PyObject * obj0 = 0 ;
3503 char *kwnames[] = {
3504 (char *) "self", NULL
3505 };
3506
3507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashes",kwnames,&obj0)) 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 {
3511 PyThreadState* __tstate = wxPyBeginAllowThreads();
3512 result = (PyObject *)wxPen_GetDashes(arg1);
3513
3514 wxPyEndAllowThreads(__tstate);
3515 if (PyErr_Occurred()) SWIG_fail;
3516 }
3517 resultobj = result;
3518 return resultobj;
3519 fail:
3520 return NULL;
3521 }
3522
3523
3524 static PyObject *_wrap_Pen__SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3525 PyObject *resultobj;
3526 wxPen *arg1 = (wxPen *) 0 ;
3527 PyObject *arg2 = (PyObject *) 0 ;
3528 PyObject *arg3 = (PyObject *) 0 ;
3529 PyObject * obj0 = 0 ;
3530 PyObject * obj1 = 0 ;
3531 PyObject * obj2 = 0 ;
3532 char *kwnames[] = {
3533 (char *) "self",(char *) "_self",(char *) "pyDashes", NULL
3534 };
3535
3536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Pen__SetDashes",kwnames,&obj0,&obj1,&obj2)) goto fail;
3537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3538 if (SWIG_arg_fail(1)) SWIG_fail;
3539 arg2 = obj1;
3540 arg3 = obj2;
3541 {
3542 PyThreadState* __tstate = wxPyBeginAllowThreads();
3543 wxPen__SetDashes(arg1,arg2,arg3);
3544
3545 wxPyEndAllowThreads(__tstate);
3546 if (PyErr_Occurred()) SWIG_fail;
3547 }
3548 Py_INCREF(Py_None); resultobj = Py_None;
3549 return resultobj;
3550 fail:
3551 return NULL;
3552 }
3553
3554
3555 static PyObject *_wrap_Pen___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3556 PyObject *resultobj;
3557 wxPen *arg1 = (wxPen *) 0 ;
3558 wxPen *arg2 = (wxPen *) 0 ;
3559 bool result;
3560 PyObject * obj0 = 0 ;
3561 PyObject * obj1 = 0 ;
3562 char *kwnames[] = {
3563 (char *) "self",(char *) "other", NULL
3564 };
3565
3566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___eq__",kwnames,&obj0,&obj1)) goto fail;
3567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3568 if (SWIG_arg_fail(1)) SWIG_fail;
3569 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3570 if (SWIG_arg_fail(2)) SWIG_fail;
3571 {
3572 PyThreadState* __tstate = wxPyBeginAllowThreads();
3573 result = (bool)wxPen___eq__(arg1,(wxPen const *)arg2);
3574
3575 wxPyEndAllowThreads(__tstate);
3576 if (PyErr_Occurred()) SWIG_fail;
3577 }
3578 {
3579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3580 }
3581 return resultobj;
3582 fail:
3583 return NULL;
3584 }
3585
3586
3587 static PyObject *_wrap_Pen___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3588 PyObject *resultobj;
3589 wxPen *arg1 = (wxPen *) 0 ;
3590 wxPen *arg2 = (wxPen *) 0 ;
3591 bool result;
3592 PyObject * obj0 = 0 ;
3593 PyObject * obj1 = 0 ;
3594 char *kwnames[] = {
3595 (char *) "self",(char *) "other", NULL
3596 };
3597
3598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___ne__",kwnames,&obj0,&obj1)) goto fail;
3599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3600 if (SWIG_arg_fail(1)) SWIG_fail;
3601 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3602 if (SWIG_arg_fail(2)) SWIG_fail;
3603 {
3604 PyThreadState* __tstate = wxPyBeginAllowThreads();
3605 result = (bool)wxPen___ne__(arg1,(wxPen const *)arg2);
3606
3607 wxPyEndAllowThreads(__tstate);
3608 if (PyErr_Occurred()) SWIG_fail;
3609 }
3610 {
3611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3612 }
3613 return resultobj;
3614 fail:
3615 return NULL;
3616 }
3617
3618
3619 static PyObject * Pen_swigregister(PyObject *, PyObject *args) {
3620 PyObject *obj;
3621 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3622 SWIG_TypeClientData(SWIGTYPE_p_wxPen, obj);
3623 Py_INCREF(obj);
3624 return Py_BuildValue((char *)"");
3625 }
3626 static PyObject *_wrap_new_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3627 PyObject *resultobj;
3628 wxColour *arg1 = 0 ;
3629 int arg2 = (int) wxSOLID ;
3630 wxBrush *result;
3631 wxColour temp1 ;
3632 PyObject * obj0 = 0 ;
3633 PyObject * obj1 = 0 ;
3634 char *kwnames[] = {
3635 (char *) "colour",(char *) "style", NULL
3636 };
3637
3638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Brush",kwnames,&obj0,&obj1)) goto fail;
3639 {
3640 arg1 = &temp1;
3641 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3642 }
3643 if (obj1) {
3644 {
3645 arg2 = (int)(SWIG_As_int(obj1));
3646 if (SWIG_arg_fail(2)) SWIG_fail;
3647 }
3648 }
3649 {
3650 if (!wxPyCheckForApp()) SWIG_fail;
3651 PyThreadState* __tstate = wxPyBeginAllowThreads();
3652 result = (wxBrush *)new wxBrush((wxColour const &)*arg1,arg2);
3653
3654 wxPyEndAllowThreads(__tstate);
3655 if (PyErr_Occurred()) SWIG_fail;
3656 }
3657 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 1);
3658 return resultobj;
3659 fail:
3660 return NULL;
3661 }
3662
3663
3664 static PyObject *_wrap_delete_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3665 PyObject *resultobj;
3666 wxBrush *arg1 = (wxBrush *) 0 ;
3667 PyObject * obj0 = 0 ;
3668 char *kwnames[] = {
3669 (char *) "self", NULL
3670 };
3671
3672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Brush",kwnames,&obj0)) goto fail;
3673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3674 if (SWIG_arg_fail(1)) SWIG_fail;
3675 {
3676 PyThreadState* __tstate = wxPyBeginAllowThreads();
3677 delete arg1;
3678
3679 wxPyEndAllowThreads(__tstate);
3680 if (PyErr_Occurred()) SWIG_fail;
3681 }
3682 Py_INCREF(Py_None); resultobj = Py_None;
3683 return resultobj;
3684 fail:
3685 return NULL;
3686 }
3687
3688
3689 static PyObject *_wrap_Brush_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3690 PyObject *resultobj;
3691 wxBrush *arg1 = (wxBrush *) 0 ;
3692 wxColour *arg2 = 0 ;
3693 wxColour temp2 ;
3694 PyObject * obj0 = 0 ;
3695 PyObject * obj1 = 0 ;
3696 char *kwnames[] = {
3697 (char *) "self",(char *) "col", NULL
3698 };
3699
3700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetColour",kwnames,&obj0,&obj1)) goto fail;
3701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3702 if (SWIG_arg_fail(1)) SWIG_fail;
3703 {
3704 arg2 = &temp2;
3705 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3706 }
3707 {
3708 PyThreadState* __tstate = wxPyBeginAllowThreads();
3709 (arg1)->SetColour((wxColour const &)*arg2);
3710
3711 wxPyEndAllowThreads(__tstate);
3712 if (PyErr_Occurred()) SWIG_fail;
3713 }
3714 Py_INCREF(Py_None); resultobj = Py_None;
3715 return resultobj;
3716 fail:
3717 return NULL;
3718 }
3719
3720
3721 static PyObject *_wrap_Brush_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3722 PyObject *resultobj;
3723 wxBrush *arg1 = (wxBrush *) 0 ;
3724 int arg2 ;
3725 PyObject * obj0 = 0 ;
3726 PyObject * obj1 = 0 ;
3727 char *kwnames[] = {
3728 (char *) "self",(char *) "style", NULL
3729 };
3730
3731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3733 if (SWIG_arg_fail(1)) SWIG_fail;
3734 {
3735 arg2 = (int)(SWIG_As_int(obj1));
3736 if (SWIG_arg_fail(2)) SWIG_fail;
3737 }
3738 {
3739 PyThreadState* __tstate = wxPyBeginAllowThreads();
3740 (arg1)->SetStyle(arg2);
3741
3742 wxPyEndAllowThreads(__tstate);
3743 if (PyErr_Occurred()) SWIG_fail;
3744 }
3745 Py_INCREF(Py_None); resultobj = Py_None;
3746 return resultobj;
3747 fail:
3748 return NULL;
3749 }
3750
3751
3752 static PyObject *_wrap_Brush_SetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3753 PyObject *resultobj;
3754 wxBrush *arg1 = (wxBrush *) 0 ;
3755 wxBitmap *arg2 = 0 ;
3756 PyObject * obj0 = 0 ;
3757 PyObject * obj1 = 0 ;
3758 char *kwnames[] = {
3759 (char *) "self",(char *) "stipple", NULL
3760 };
3761
3762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStipple",kwnames,&obj0,&obj1)) goto fail;
3763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3764 if (SWIG_arg_fail(1)) SWIG_fail;
3765 {
3766 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3767 if (SWIG_arg_fail(2)) SWIG_fail;
3768 if (arg2 == NULL) {
3769 SWIG_null_ref("wxBitmap");
3770 }
3771 if (SWIG_arg_fail(2)) SWIG_fail;
3772 }
3773 {
3774 PyThreadState* __tstate = wxPyBeginAllowThreads();
3775 (arg1)->SetStipple((wxBitmap const &)*arg2);
3776
3777 wxPyEndAllowThreads(__tstate);
3778 if (PyErr_Occurred()) SWIG_fail;
3779 }
3780 Py_INCREF(Py_None); resultobj = Py_None;
3781 return resultobj;
3782 fail:
3783 return NULL;
3784 }
3785
3786
3787 static PyObject *_wrap_Brush_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3788 PyObject *resultobj;
3789 wxBrush *arg1 = (wxBrush *) 0 ;
3790 wxColour result;
3791 PyObject * obj0 = 0 ;
3792 char *kwnames[] = {
3793 (char *) "self", NULL
3794 };
3795
3796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetColour",kwnames,&obj0)) goto fail;
3797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3798 if (SWIG_arg_fail(1)) SWIG_fail;
3799 {
3800 PyThreadState* __tstate = wxPyBeginAllowThreads();
3801 result = ((wxBrush const *)arg1)->GetColour();
3802
3803 wxPyEndAllowThreads(__tstate);
3804 if (PyErr_Occurred()) SWIG_fail;
3805 }
3806 {
3807 wxColour * resultptr;
3808 resultptr = new wxColour((wxColour &)(result));
3809 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3810 }
3811 return resultobj;
3812 fail:
3813 return NULL;
3814 }
3815
3816
3817 static PyObject *_wrap_Brush_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3818 PyObject *resultobj;
3819 wxBrush *arg1 = (wxBrush *) 0 ;
3820 int result;
3821 PyObject * obj0 = 0 ;
3822 char *kwnames[] = {
3823 (char *) "self", NULL
3824 };
3825
3826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStyle",kwnames,&obj0)) goto fail;
3827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3828 if (SWIG_arg_fail(1)) SWIG_fail;
3829 {
3830 PyThreadState* __tstate = wxPyBeginAllowThreads();
3831 result = (int)((wxBrush const *)arg1)->GetStyle();
3832
3833 wxPyEndAllowThreads(__tstate);
3834 if (PyErr_Occurred()) SWIG_fail;
3835 }
3836 {
3837 resultobj = SWIG_From_int((int)(result));
3838 }
3839 return resultobj;
3840 fail:
3841 return NULL;
3842 }
3843
3844
3845 static PyObject *_wrap_Brush_GetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3846 PyObject *resultobj;
3847 wxBrush *arg1 = (wxBrush *) 0 ;
3848 wxBitmap *result;
3849 PyObject * obj0 = 0 ;
3850 char *kwnames[] = {
3851 (char *) "self", NULL
3852 };
3853
3854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStipple",kwnames,&obj0)) goto fail;
3855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3856 if (SWIG_arg_fail(1)) SWIG_fail;
3857 {
3858 PyThreadState* __tstate = wxPyBeginAllowThreads();
3859 result = (wxBitmap *)((wxBrush const *)arg1)->GetStipple();
3860
3861 wxPyEndAllowThreads(__tstate);
3862 if (PyErr_Occurred()) SWIG_fail;
3863 }
3864 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 0);
3865 return resultobj;
3866 fail:
3867 return NULL;
3868 }
3869
3870
3871 static PyObject *_wrap_Brush_IsHatch(PyObject *, PyObject *args, PyObject *kwargs) {
3872 PyObject *resultobj;
3873 wxBrush *arg1 = (wxBrush *) 0 ;
3874 bool result;
3875 PyObject * obj0 = 0 ;
3876 char *kwnames[] = {
3877 (char *) "self", NULL
3878 };
3879
3880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_IsHatch",kwnames,&obj0)) goto fail;
3881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3882 if (SWIG_arg_fail(1)) SWIG_fail;
3883 {
3884 PyThreadState* __tstate = wxPyBeginAllowThreads();
3885 result = (bool)((wxBrush const *)arg1)->IsHatch();
3886
3887 wxPyEndAllowThreads(__tstate);
3888 if (PyErr_Occurred()) SWIG_fail;
3889 }
3890 {
3891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3892 }
3893 return resultobj;
3894 fail:
3895 return NULL;
3896 }
3897
3898
3899 static PyObject *_wrap_Brush_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3900 PyObject *resultobj;
3901 wxBrush *arg1 = (wxBrush *) 0 ;
3902 bool result;
3903 PyObject * obj0 = 0 ;
3904 char *kwnames[] = {
3905 (char *) "self", NULL
3906 };
3907
3908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_Ok",kwnames,&obj0)) goto fail;
3909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3910 if (SWIG_arg_fail(1)) SWIG_fail;
3911 {
3912 PyThreadState* __tstate = wxPyBeginAllowThreads();
3913 result = (bool)(arg1)->Ok();
3914
3915 wxPyEndAllowThreads(__tstate);
3916 if (PyErr_Occurred()) SWIG_fail;
3917 }
3918 {
3919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3920 }
3921 return resultobj;
3922 fail:
3923 return NULL;
3924 }
3925
3926
3927 static PyObject *_wrap_Brush_MacGetTheme(PyObject *, PyObject *args, PyObject *kwargs) {
3928 PyObject *resultobj;
3929 wxBrush *arg1 = (wxBrush *) 0 ;
3930 short result;
3931 PyObject * obj0 = 0 ;
3932 char *kwnames[] = {
3933 (char *) "self", NULL
3934 };
3935
3936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_MacGetTheme",kwnames,&obj0)) goto fail;
3937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3938 if (SWIG_arg_fail(1)) SWIG_fail;
3939 {
3940 PyThreadState* __tstate = wxPyBeginAllowThreads();
3941 result = (short)(arg1)->MacGetTheme();
3942
3943 wxPyEndAllowThreads(__tstate);
3944 if (PyErr_Occurred()) SWIG_fail;
3945 }
3946 {
3947 resultobj = SWIG_From_short((short)(result));
3948 }
3949 return resultobj;
3950 fail:
3951 return NULL;
3952 }
3953
3954
3955 static PyObject *_wrap_Brush_MacSetTheme(PyObject *, PyObject *args, PyObject *kwargs) {
3956 PyObject *resultobj;
3957 wxBrush *arg1 = (wxBrush *) 0 ;
3958 short arg2 ;
3959 PyObject * obj0 = 0 ;
3960 PyObject * obj1 = 0 ;
3961 char *kwnames[] = {
3962 (char *) "self",(char *) "macThemeBrush", NULL
3963 };
3964
3965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_MacSetTheme",kwnames,&obj0,&obj1)) goto fail;
3966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3967 if (SWIG_arg_fail(1)) SWIG_fail;
3968 {
3969 arg2 = (short)(SWIG_As_short(obj1));
3970 if (SWIG_arg_fail(2)) SWIG_fail;
3971 }
3972 {
3973 PyThreadState* __tstate = wxPyBeginAllowThreads();
3974 (arg1)->MacSetTheme(arg2);
3975
3976 wxPyEndAllowThreads(__tstate);
3977 if (PyErr_Occurred()) SWIG_fail;
3978 }
3979 Py_INCREF(Py_None); resultobj = Py_None;
3980 return resultobj;
3981 fail:
3982 return NULL;
3983 }
3984
3985
3986 static PyObject * Brush_swigregister(PyObject *, PyObject *args) {
3987 PyObject *obj;
3988 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3989 SWIG_TypeClientData(SWIGTYPE_p_wxBrush, obj);
3990 Py_INCREF(obj);
3991 return Py_BuildValue((char *)"");
3992 }
3993 static PyObject *_wrap_new_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
3994 PyObject *resultobj;
3995 wxString *arg1 = 0 ;
3996 wxBitmapType arg2 = (wxBitmapType) wxBITMAP_TYPE_ANY ;
3997 wxBitmap *result;
3998 bool temp1 = false ;
3999 PyObject * obj0 = 0 ;
4000 PyObject * obj1 = 0 ;
4001 char *kwnames[] = {
4002 (char *) "name",(char *) "type", NULL
4003 };
4004
4005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Bitmap",kwnames,&obj0,&obj1)) goto fail;
4006 {
4007 arg1 = wxString_in_helper(obj0);
4008 if (arg1 == NULL) SWIG_fail;
4009 temp1 = true;
4010 }
4011 if (obj1) {
4012 {
4013 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
4014 if (SWIG_arg_fail(2)) SWIG_fail;
4015 }
4016 }
4017 {
4018 if (!wxPyCheckForApp()) SWIG_fail;
4019 PyThreadState* __tstate = wxPyBeginAllowThreads();
4020 result = (wxBitmap *)new wxBitmap((wxString const &)*arg1,(wxBitmapType )arg2);
4021
4022 wxPyEndAllowThreads(__tstate);
4023 if (PyErr_Occurred()) SWIG_fail;
4024 }
4025 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4026 {
4027 if (temp1)
4028 delete arg1;
4029 }
4030 return resultobj;
4031 fail:
4032 {
4033 if (temp1)
4034 delete arg1;
4035 }
4036 return NULL;
4037 }
4038
4039
4040 static PyObject *_wrap_delete_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4041 PyObject *resultobj;
4042 wxBitmap *arg1 = (wxBitmap *) 0 ;
4043 PyObject * obj0 = 0 ;
4044 char *kwnames[] = {
4045 (char *) "self", NULL
4046 };
4047
4048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Bitmap",kwnames,&obj0)) goto fail;
4049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4050 if (SWIG_arg_fail(1)) SWIG_fail;
4051 {
4052 PyThreadState* __tstate = wxPyBeginAllowThreads();
4053 delete arg1;
4054
4055 wxPyEndAllowThreads(__tstate);
4056 if (PyErr_Occurred()) SWIG_fail;
4057 }
4058 Py_INCREF(Py_None); resultobj = Py_None;
4059 return resultobj;
4060 fail:
4061 return NULL;
4062 }
4063
4064
4065 static PyObject *_wrap_new_EmptyBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4066 PyObject *resultobj;
4067 int arg1 ;
4068 int arg2 ;
4069 int arg3 = (int) -1 ;
4070 wxBitmap *result;
4071 PyObject * obj0 = 0 ;
4072 PyObject * obj1 = 0 ;
4073 PyObject * obj2 = 0 ;
4074 char *kwnames[] = {
4075 (char *) "width",(char *) "height",(char *) "depth", NULL
4076 };
4077
4078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_EmptyBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
4079 {
4080 arg1 = (int)(SWIG_As_int(obj0));
4081 if (SWIG_arg_fail(1)) SWIG_fail;
4082 }
4083 {
4084 arg2 = (int)(SWIG_As_int(obj1));
4085 if (SWIG_arg_fail(2)) SWIG_fail;
4086 }
4087 if (obj2) {
4088 {
4089 arg3 = (int)(SWIG_As_int(obj2));
4090 if (SWIG_arg_fail(3)) SWIG_fail;
4091 }
4092 }
4093 {
4094 if (!wxPyCheckForApp()) SWIG_fail;
4095 PyThreadState* __tstate = wxPyBeginAllowThreads();
4096 result = (wxBitmap *)new wxBitmap(arg1,arg2,arg3);
4097
4098 wxPyEndAllowThreads(__tstate);
4099 if (PyErr_Occurred()) SWIG_fail;
4100 }
4101 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4102 return resultobj;
4103 fail:
4104 return NULL;
4105 }
4106
4107
4108 static PyObject *_wrap_new_BitmapFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4109 PyObject *resultobj;
4110 wxIcon *arg1 = 0 ;
4111 wxBitmap *result;
4112 PyObject * obj0 = 0 ;
4113 char *kwnames[] = {
4114 (char *) "icon", NULL
4115 };
4116
4117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromIcon",kwnames,&obj0)) goto fail;
4118 {
4119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4120 if (SWIG_arg_fail(1)) SWIG_fail;
4121 if (arg1 == NULL) {
4122 SWIG_null_ref("wxIcon");
4123 }
4124 if (SWIG_arg_fail(1)) SWIG_fail;
4125 }
4126 {
4127 if (!wxPyCheckForApp()) SWIG_fail;
4128 PyThreadState* __tstate = wxPyBeginAllowThreads();
4129 result = (wxBitmap *)new wxBitmap((wxIcon const &)*arg1);
4130
4131 wxPyEndAllowThreads(__tstate);
4132 if (PyErr_Occurred()) SWIG_fail;
4133 }
4134 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4135 return resultobj;
4136 fail:
4137 return NULL;
4138 }
4139
4140
4141 static PyObject *_wrap_new_BitmapFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
4142 PyObject *resultobj;
4143 wxImage *arg1 = 0 ;
4144 int arg2 = (int) -1 ;
4145 wxBitmap *result;
4146 PyObject * obj0 = 0 ;
4147 PyObject * obj1 = 0 ;
4148 char *kwnames[] = {
4149 (char *) "image",(char *) "depth", NULL
4150 };
4151
4152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BitmapFromImage",kwnames,&obj0,&obj1)) goto fail;
4153 {
4154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
4155 if (SWIG_arg_fail(1)) SWIG_fail;
4156 if (arg1 == NULL) {
4157 SWIG_null_ref("wxImage");
4158 }
4159 if (SWIG_arg_fail(1)) SWIG_fail;
4160 }
4161 if (obj1) {
4162 {
4163 arg2 = (int)(SWIG_As_int(obj1));
4164 if (SWIG_arg_fail(2)) SWIG_fail;
4165 }
4166 }
4167 {
4168 if (!wxPyCheckForApp()) SWIG_fail;
4169 PyThreadState* __tstate = wxPyBeginAllowThreads();
4170 result = (wxBitmap *)new wxBitmap((wxImage const &)*arg1,arg2);
4171
4172 wxPyEndAllowThreads(__tstate);
4173 if (PyErr_Occurred()) SWIG_fail;
4174 }
4175 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4176 return resultobj;
4177 fail:
4178 return NULL;
4179 }
4180
4181
4182 static PyObject *_wrap_new_BitmapFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
4183 PyObject *resultobj;
4184 PyObject *arg1 = (PyObject *) 0 ;
4185 wxBitmap *result;
4186 PyObject * obj0 = 0 ;
4187 char *kwnames[] = {
4188 (char *) "listOfStrings", NULL
4189 };
4190
4191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromXPMData",kwnames,&obj0)) goto fail;
4192 arg1 = obj0;
4193 {
4194 if (!wxPyCheckForApp()) SWIG_fail;
4195 PyThreadState* __tstate = wxPyBeginAllowThreads();
4196 result = (wxBitmap *)new_wxBitmap(arg1);
4197
4198 wxPyEndAllowThreads(__tstate);
4199 if (PyErr_Occurred()) SWIG_fail;
4200 }
4201 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4202 return resultobj;
4203 fail:
4204 return NULL;
4205 }
4206
4207
4208 static PyObject *_wrap_new_BitmapFromBits(PyObject *, PyObject *args, PyObject *kwargs) {
4209 PyObject *resultobj;
4210 PyObject *arg1 = (PyObject *) 0 ;
4211 int arg2 ;
4212 int arg3 ;
4213 int arg4 = (int) 1 ;
4214 wxBitmap *result;
4215 PyObject * obj0 = 0 ;
4216 PyObject * obj1 = 0 ;
4217 PyObject * obj2 = 0 ;
4218 PyObject * obj3 = 0 ;
4219 char *kwnames[] = {
4220 (char *) "bits",(char *) "width",(char *) "height",(char *) "depth", NULL
4221 };
4222
4223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:new_BitmapFromBits",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4224 arg1 = obj0;
4225 {
4226 arg2 = (int)(SWIG_As_int(obj1));
4227 if (SWIG_arg_fail(2)) SWIG_fail;
4228 }
4229 {
4230 arg3 = (int)(SWIG_As_int(obj2));
4231 if (SWIG_arg_fail(3)) SWIG_fail;
4232 }
4233 if (obj3) {
4234 {
4235 arg4 = (int)(SWIG_As_int(obj3));
4236 if (SWIG_arg_fail(4)) SWIG_fail;
4237 }
4238 }
4239 {
4240 if (!wxPyCheckForApp()) SWIG_fail;
4241 PyThreadState* __tstate = wxPyBeginAllowThreads();
4242 result = (wxBitmap *)new_wxBitmap(arg1,arg2,arg3,arg4);
4243
4244 wxPyEndAllowThreads(__tstate);
4245 if (PyErr_Occurred()) SWIG_fail;
4246 }
4247 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4248 return resultobj;
4249 fail:
4250 return NULL;
4251 }
4252
4253
4254 static PyObject *_wrap_Bitmap_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
4255 PyObject *resultobj;
4256 wxBitmap *arg1 = (wxBitmap *) 0 ;
4257 bool result;
4258 PyObject * obj0 = 0 ;
4259 char *kwnames[] = {
4260 (char *) "self", NULL
4261 };
4262
4263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_Ok",kwnames,&obj0)) goto fail;
4264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4265 if (SWIG_arg_fail(1)) SWIG_fail;
4266 {
4267 PyThreadState* __tstate = wxPyBeginAllowThreads();
4268 result = (bool)(arg1)->Ok();
4269
4270 wxPyEndAllowThreads(__tstate);
4271 if (PyErr_Occurred()) SWIG_fail;
4272 }
4273 {
4274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4275 }
4276 return resultobj;
4277 fail:
4278 return NULL;
4279 }
4280
4281
4282 static PyObject *_wrap_Bitmap_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4283 PyObject *resultobj;
4284 wxBitmap *arg1 = (wxBitmap *) 0 ;
4285 int result;
4286 PyObject * obj0 = 0 ;
4287 char *kwnames[] = {
4288 (char *) "self", NULL
4289 };
4290
4291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetWidth",kwnames,&obj0)) goto fail;
4292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4293 if (SWIG_arg_fail(1)) SWIG_fail;
4294 {
4295 PyThreadState* __tstate = wxPyBeginAllowThreads();
4296 result = (int)(arg1)->GetWidth();
4297
4298 wxPyEndAllowThreads(__tstate);
4299 if (PyErr_Occurred()) SWIG_fail;
4300 }
4301 {
4302 resultobj = SWIG_From_int((int)(result));
4303 }
4304 return resultobj;
4305 fail:
4306 return NULL;
4307 }
4308
4309
4310 static PyObject *_wrap_Bitmap_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4311 PyObject *resultobj;
4312 wxBitmap *arg1 = (wxBitmap *) 0 ;
4313 int result;
4314 PyObject * obj0 = 0 ;
4315 char *kwnames[] = {
4316 (char *) "self", NULL
4317 };
4318
4319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetHeight",kwnames,&obj0)) goto fail;
4320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4321 if (SWIG_arg_fail(1)) SWIG_fail;
4322 {
4323 PyThreadState* __tstate = wxPyBeginAllowThreads();
4324 result = (int)(arg1)->GetHeight();
4325
4326 wxPyEndAllowThreads(__tstate);
4327 if (PyErr_Occurred()) SWIG_fail;
4328 }
4329 {
4330 resultobj = SWIG_From_int((int)(result));
4331 }
4332 return resultobj;
4333 fail:
4334 return NULL;
4335 }
4336
4337
4338 static PyObject *_wrap_Bitmap_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4339 PyObject *resultobj;
4340 wxBitmap *arg1 = (wxBitmap *) 0 ;
4341 int result;
4342 PyObject * obj0 = 0 ;
4343 char *kwnames[] = {
4344 (char *) "self", NULL
4345 };
4346
4347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetDepth",kwnames,&obj0)) goto fail;
4348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4349 if (SWIG_arg_fail(1)) SWIG_fail;
4350 {
4351 PyThreadState* __tstate = wxPyBeginAllowThreads();
4352 result = (int)(arg1)->GetDepth();
4353
4354 wxPyEndAllowThreads(__tstate);
4355 if (PyErr_Occurred()) SWIG_fail;
4356 }
4357 {
4358 resultobj = SWIG_From_int((int)(result));
4359 }
4360 return resultobj;
4361 fail:
4362 return NULL;
4363 }
4364
4365
4366 static PyObject *_wrap_Bitmap_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4367 PyObject *resultobj;
4368 wxBitmap *arg1 = (wxBitmap *) 0 ;
4369 wxSize result;
4370 PyObject * obj0 = 0 ;
4371 char *kwnames[] = {
4372 (char *) "self", NULL
4373 };
4374
4375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetSize",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 = wxBitmap_GetSize(arg1);
4381
4382 wxPyEndAllowThreads(__tstate);
4383 if (PyErr_Occurred()) SWIG_fail;
4384 }
4385 {
4386 wxSize * resultptr;
4387 resultptr = new wxSize((wxSize &)(result));
4388 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
4389 }
4390 return resultobj;
4391 fail:
4392 return NULL;
4393 }
4394
4395
4396 static PyObject *_wrap_Bitmap_ConvertToImage(PyObject *, PyObject *args, PyObject *kwargs) {
4397 PyObject *resultobj;
4398 wxBitmap *arg1 = (wxBitmap *) 0 ;
4399 SwigValueWrapper<wxImage > result;
4400 PyObject * obj0 = 0 ;
4401 char *kwnames[] = {
4402 (char *) "self", NULL
4403 };
4404
4405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_ConvertToImage",kwnames,&obj0)) goto fail;
4406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4407 if (SWIG_arg_fail(1)) SWIG_fail;
4408 {
4409 PyThreadState* __tstate = wxPyBeginAllowThreads();
4410 result = ((wxBitmap const *)arg1)->ConvertToImage();
4411
4412 wxPyEndAllowThreads(__tstate);
4413 if (PyErr_Occurred()) SWIG_fail;
4414 }
4415 {
4416 wxImage * resultptr;
4417 resultptr = new wxImage((wxImage &)(result));
4418 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
4419 }
4420 return resultobj;
4421 fail:
4422 return NULL;
4423 }
4424
4425
4426 static PyObject *_wrap_Bitmap_GetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4427 PyObject *resultobj;
4428 wxBitmap *arg1 = (wxBitmap *) 0 ;
4429 wxMask *result;
4430 PyObject * obj0 = 0 ;
4431 char *kwnames[] = {
4432 (char *) "self", NULL
4433 };
4434
4435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetMask",kwnames,&obj0)) goto fail;
4436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4437 if (SWIG_arg_fail(1)) SWIG_fail;
4438 {
4439 PyThreadState* __tstate = wxPyBeginAllowThreads();
4440 result = (wxMask *)((wxBitmap const *)arg1)->GetMask();
4441
4442 wxPyEndAllowThreads(__tstate);
4443 if (PyErr_Occurred()) SWIG_fail;
4444 }
4445 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 0);
4446 return resultobj;
4447 fail:
4448 return NULL;
4449 }
4450
4451
4452 static PyObject *_wrap_Bitmap_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4453 PyObject *resultobj;
4454 wxBitmap *arg1 = (wxBitmap *) 0 ;
4455 wxMask *arg2 = (wxMask *) 0 ;
4456 PyObject * obj0 = 0 ;
4457 PyObject * obj1 = 0 ;
4458 char *kwnames[] = {
4459 (char *) "self",(char *) "mask", NULL
4460 };
4461
4462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMask",kwnames,&obj0,&obj1)) goto fail;
4463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4464 if (SWIG_arg_fail(1)) SWIG_fail;
4465 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMask, SWIG_POINTER_EXCEPTION | 0);
4466 if (SWIG_arg_fail(2)) SWIG_fail;
4467 {
4468 PyThreadState* __tstate = wxPyBeginAllowThreads();
4469 (arg1)->SetMask(arg2);
4470
4471 wxPyEndAllowThreads(__tstate);
4472 if (PyErr_Occurred()) SWIG_fail;
4473 }
4474 Py_INCREF(Py_None); resultobj = Py_None;
4475 return resultobj;
4476 fail:
4477 return NULL;
4478 }
4479
4480
4481 static PyObject *_wrap_Bitmap_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
4482 PyObject *resultobj;
4483 wxBitmap *arg1 = (wxBitmap *) 0 ;
4484 wxColour *arg2 = 0 ;
4485 wxColour temp2 ;
4486 PyObject * obj0 = 0 ;
4487 PyObject * obj1 = 0 ;
4488 char *kwnames[] = {
4489 (char *) "self",(char *) "colour", NULL
4490 };
4491
4492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMaskColour",kwnames,&obj0,&obj1)) goto fail;
4493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4494 if (SWIG_arg_fail(1)) SWIG_fail;
4495 {
4496 arg2 = &temp2;
4497 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4498 }
4499 {
4500 PyThreadState* __tstate = wxPyBeginAllowThreads();
4501 wxBitmap_SetMaskColour(arg1,(wxColour const &)*arg2);
4502
4503 wxPyEndAllowThreads(__tstate);
4504 if (PyErr_Occurred()) SWIG_fail;
4505 }
4506 Py_INCREF(Py_None); resultobj = Py_None;
4507 return resultobj;
4508 fail:
4509 return NULL;
4510 }
4511
4512
4513 static PyObject *_wrap_Bitmap_GetSubBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4514 PyObject *resultobj;
4515 wxBitmap *arg1 = (wxBitmap *) 0 ;
4516 wxRect *arg2 = 0 ;
4517 SwigValueWrapper<wxBitmap > result;
4518 wxRect temp2 ;
4519 PyObject * obj0 = 0 ;
4520 PyObject * obj1 = 0 ;
4521 char *kwnames[] = {
4522 (char *) "self",(char *) "rect", NULL
4523 };
4524
4525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_GetSubBitmap",kwnames,&obj0,&obj1)) goto fail;
4526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4527 if (SWIG_arg_fail(1)) SWIG_fail;
4528 {
4529 arg2 = &temp2;
4530 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4531 }
4532 {
4533 PyThreadState* __tstate = wxPyBeginAllowThreads();
4534 result = ((wxBitmap const *)arg1)->GetSubBitmap((wxRect const &)*arg2);
4535
4536 wxPyEndAllowThreads(__tstate);
4537 if (PyErr_Occurred()) SWIG_fail;
4538 }
4539 {
4540 wxBitmap * resultptr;
4541 resultptr = new wxBitmap((wxBitmap &)(result));
4542 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
4543 }
4544 return resultobj;
4545 fail:
4546 return NULL;
4547 }
4548
4549
4550 static PyObject *_wrap_Bitmap_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
4551 PyObject *resultobj;
4552 wxBitmap *arg1 = (wxBitmap *) 0 ;
4553 wxString *arg2 = 0 ;
4554 wxBitmapType arg3 ;
4555 wxPalette *arg4 = (wxPalette *) NULL ;
4556 bool result;
4557 bool temp2 = false ;
4558 PyObject * obj0 = 0 ;
4559 PyObject * obj1 = 0 ;
4560 PyObject * obj2 = 0 ;
4561 PyObject * obj3 = 0 ;
4562 char *kwnames[] = {
4563 (char *) "self",(char *) "name",(char *) "type",(char *) "palette", NULL
4564 };
4565
4566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Bitmap_SaveFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4568 if (SWIG_arg_fail(1)) SWIG_fail;
4569 {
4570 arg2 = wxString_in_helper(obj1);
4571 if (arg2 == NULL) SWIG_fail;
4572 temp2 = true;
4573 }
4574 {
4575 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4576 if (SWIG_arg_fail(3)) SWIG_fail;
4577 }
4578 if (obj3) {
4579 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
4580 if (SWIG_arg_fail(4)) SWIG_fail;
4581 }
4582 {
4583 PyThreadState* __tstate = wxPyBeginAllowThreads();
4584 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxBitmapType )arg3,arg4);
4585
4586 wxPyEndAllowThreads(__tstate);
4587 if (PyErr_Occurred()) SWIG_fail;
4588 }
4589 {
4590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4591 }
4592 {
4593 if (temp2)
4594 delete arg2;
4595 }
4596 return resultobj;
4597 fail:
4598 {
4599 if (temp2)
4600 delete arg2;
4601 }
4602 return NULL;
4603 }
4604
4605
4606 static PyObject *_wrap_Bitmap_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
4607 PyObject *resultobj;
4608 wxBitmap *arg1 = (wxBitmap *) 0 ;
4609 wxString *arg2 = 0 ;
4610 wxBitmapType arg3 ;
4611 bool result;
4612 bool temp2 = false ;
4613 PyObject * obj0 = 0 ;
4614 PyObject * obj1 = 0 ;
4615 PyObject * obj2 = 0 ;
4616 char *kwnames[] = {
4617 (char *) "self",(char *) "name",(char *) "type", NULL
4618 };
4619
4620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Bitmap_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
4621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4622 if (SWIG_arg_fail(1)) SWIG_fail;
4623 {
4624 arg2 = wxString_in_helper(obj1);
4625 if (arg2 == NULL) SWIG_fail;
4626 temp2 = true;
4627 }
4628 {
4629 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4630 if (SWIG_arg_fail(3)) SWIG_fail;
4631 }
4632 {
4633 PyThreadState* __tstate = wxPyBeginAllowThreads();
4634 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
4635
4636 wxPyEndAllowThreads(__tstate);
4637 if (PyErr_Occurred()) SWIG_fail;
4638 }
4639 {
4640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4641 }
4642 {
4643 if (temp2)
4644 delete arg2;
4645 }
4646 return resultobj;
4647 fail:
4648 {
4649 if (temp2)
4650 delete arg2;
4651 }
4652 return NULL;
4653 }
4654
4655
4656 static PyObject *_wrap_Bitmap_GetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
4657 PyObject *resultobj;
4658 wxBitmap *arg1 = (wxBitmap *) 0 ;
4659 wxPalette *result;
4660 PyObject * obj0 = 0 ;
4661 char *kwnames[] = {
4662 (char *) "self", NULL
4663 };
4664
4665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetPalette",kwnames,&obj0)) goto fail;
4666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4667 if (SWIG_arg_fail(1)) SWIG_fail;
4668 {
4669 PyThreadState* __tstate = wxPyBeginAllowThreads();
4670 result = (wxPalette *)((wxBitmap const *)arg1)->GetPalette();
4671
4672 wxPyEndAllowThreads(__tstate);
4673 if (PyErr_Occurred()) SWIG_fail;
4674 }
4675 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 0);
4676 return resultobj;
4677 fail:
4678 return NULL;
4679 }
4680
4681
4682 static PyObject *_wrap_Bitmap_CopyFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4683 PyObject *resultobj;
4684 wxBitmap *arg1 = (wxBitmap *) 0 ;
4685 wxIcon *arg2 = 0 ;
4686 bool result;
4687 PyObject * obj0 = 0 ;
4688 PyObject * obj1 = 0 ;
4689 char *kwnames[] = {
4690 (char *) "self",(char *) "icon", NULL
4691 };
4692
4693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromIcon",kwnames,&obj0,&obj1)) goto fail;
4694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4695 if (SWIG_arg_fail(1)) SWIG_fail;
4696 {
4697 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4698 if (SWIG_arg_fail(2)) SWIG_fail;
4699 if (arg2 == NULL) {
4700 SWIG_null_ref("wxIcon");
4701 }
4702 if (SWIG_arg_fail(2)) SWIG_fail;
4703 }
4704 {
4705 PyThreadState* __tstate = wxPyBeginAllowThreads();
4706 result = (bool)(arg1)->CopyFromIcon((wxIcon const &)*arg2);
4707
4708 wxPyEndAllowThreads(__tstate);
4709 if (PyErr_Occurred()) SWIG_fail;
4710 }
4711 {
4712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4713 }
4714 return resultobj;
4715 fail:
4716 return NULL;
4717 }
4718
4719
4720 static PyObject *_wrap_Bitmap_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4721 PyObject *resultobj;
4722 wxBitmap *arg1 = (wxBitmap *) 0 ;
4723 int arg2 ;
4724 PyObject * obj0 = 0 ;
4725 PyObject * obj1 = 0 ;
4726 char *kwnames[] = {
4727 (char *) "self",(char *) "height", NULL
4728 };
4729
4730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHeight",kwnames,&obj0,&obj1)) goto fail;
4731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4732 if (SWIG_arg_fail(1)) SWIG_fail;
4733 {
4734 arg2 = (int)(SWIG_As_int(obj1));
4735 if (SWIG_arg_fail(2)) SWIG_fail;
4736 }
4737 {
4738 PyThreadState* __tstate = wxPyBeginAllowThreads();
4739 (arg1)->SetHeight(arg2);
4740
4741 wxPyEndAllowThreads(__tstate);
4742 if (PyErr_Occurred()) SWIG_fail;
4743 }
4744 Py_INCREF(Py_None); resultobj = Py_None;
4745 return resultobj;
4746 fail:
4747 return NULL;
4748 }
4749
4750
4751 static PyObject *_wrap_Bitmap_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4752 PyObject *resultobj;
4753 wxBitmap *arg1 = (wxBitmap *) 0 ;
4754 int arg2 ;
4755 PyObject * obj0 = 0 ;
4756 PyObject * obj1 = 0 ;
4757 char *kwnames[] = {
4758 (char *) "self",(char *) "width", NULL
4759 };
4760
4761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetWidth",kwnames,&obj0,&obj1)) goto fail;
4762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4763 if (SWIG_arg_fail(1)) SWIG_fail;
4764 {
4765 arg2 = (int)(SWIG_As_int(obj1));
4766 if (SWIG_arg_fail(2)) SWIG_fail;
4767 }
4768 {
4769 PyThreadState* __tstate = wxPyBeginAllowThreads();
4770 (arg1)->SetWidth(arg2);
4771
4772 wxPyEndAllowThreads(__tstate);
4773 if (PyErr_Occurred()) SWIG_fail;
4774 }
4775 Py_INCREF(Py_None); resultobj = Py_None;
4776 return resultobj;
4777 fail:
4778 return NULL;
4779 }
4780
4781
4782 static PyObject *_wrap_Bitmap_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4783 PyObject *resultobj;
4784 wxBitmap *arg1 = (wxBitmap *) 0 ;
4785 int arg2 ;
4786 PyObject * obj0 = 0 ;
4787 PyObject * obj1 = 0 ;
4788 char *kwnames[] = {
4789 (char *) "self",(char *) "depth", NULL
4790 };
4791
4792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetDepth",kwnames,&obj0,&obj1)) goto fail;
4793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4794 if (SWIG_arg_fail(1)) SWIG_fail;
4795 {
4796 arg2 = (int)(SWIG_As_int(obj1));
4797 if (SWIG_arg_fail(2)) SWIG_fail;
4798 }
4799 {
4800 PyThreadState* __tstate = wxPyBeginAllowThreads();
4801 (arg1)->SetDepth(arg2);
4802
4803 wxPyEndAllowThreads(__tstate);
4804 if (PyErr_Occurred()) SWIG_fail;
4805 }
4806 Py_INCREF(Py_None); resultobj = Py_None;
4807 return resultobj;
4808 fail:
4809 return NULL;
4810 }
4811
4812
4813 static PyObject *_wrap_Bitmap_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4814 PyObject *resultobj;
4815 wxBitmap *arg1 = (wxBitmap *) 0 ;
4816 wxSize *arg2 = 0 ;
4817 wxSize temp2 ;
4818 PyObject * obj0 = 0 ;
4819 PyObject * obj1 = 0 ;
4820 char *kwnames[] = {
4821 (char *) "self",(char *) "size", NULL
4822 };
4823
4824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetSize",kwnames,&obj0,&obj1)) goto fail;
4825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4826 if (SWIG_arg_fail(1)) SWIG_fail;
4827 {
4828 arg2 = &temp2;
4829 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4830 }
4831 {
4832 PyThreadState* __tstate = wxPyBeginAllowThreads();
4833 wxBitmap_SetSize(arg1,(wxSize const &)*arg2);
4834
4835 wxPyEndAllowThreads(__tstate);
4836 if (PyErr_Occurred()) SWIG_fail;
4837 }
4838 Py_INCREF(Py_None); resultobj = Py_None;
4839 return resultobj;
4840 fail:
4841 return NULL;
4842 }
4843
4844
4845 static PyObject *_wrap_Bitmap___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4846 PyObject *resultobj;
4847 wxBitmap *arg1 = (wxBitmap *) 0 ;
4848 wxBitmap *arg2 = (wxBitmap *) 0 ;
4849 bool result;
4850 PyObject * obj0 = 0 ;
4851 PyObject * obj1 = 0 ;
4852 char *kwnames[] = {
4853 (char *) "self",(char *) "other", NULL
4854 };
4855
4856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___eq__",kwnames,&obj0,&obj1)) goto fail;
4857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4858 if (SWIG_arg_fail(1)) SWIG_fail;
4859 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4860 if (SWIG_arg_fail(2)) SWIG_fail;
4861 {
4862 PyThreadState* __tstate = wxPyBeginAllowThreads();
4863 result = (bool)wxBitmap___eq__(arg1,(wxBitmap const *)arg2);
4864
4865 wxPyEndAllowThreads(__tstate);
4866 if (PyErr_Occurred()) SWIG_fail;
4867 }
4868 {
4869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4870 }
4871 return resultobj;
4872 fail:
4873 return NULL;
4874 }
4875
4876
4877 static PyObject *_wrap_Bitmap___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4878 PyObject *resultobj;
4879 wxBitmap *arg1 = (wxBitmap *) 0 ;
4880 wxBitmap *arg2 = (wxBitmap *) 0 ;
4881 bool result;
4882 PyObject * obj0 = 0 ;
4883 PyObject * obj1 = 0 ;
4884 char *kwnames[] = {
4885 (char *) "self",(char *) "other", NULL
4886 };
4887
4888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___ne__",kwnames,&obj0,&obj1)) goto fail;
4889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4890 if (SWIG_arg_fail(1)) SWIG_fail;
4891 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4892 if (SWIG_arg_fail(2)) SWIG_fail;
4893 {
4894 PyThreadState* __tstate = wxPyBeginAllowThreads();
4895 result = (bool)wxBitmap___ne__(arg1,(wxBitmap const *)arg2);
4896
4897 wxPyEndAllowThreads(__tstate);
4898 if (PyErr_Occurred()) SWIG_fail;
4899 }
4900 {
4901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4902 }
4903 return resultobj;
4904 fail:
4905 return NULL;
4906 }
4907
4908
4909 static PyObject * Bitmap_swigregister(PyObject *, PyObject *args) {
4910 PyObject *obj;
4911 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4912 SWIG_TypeClientData(SWIGTYPE_p_wxBitmap, obj);
4913 Py_INCREF(obj);
4914 return Py_BuildValue((char *)"");
4915 }
4916 static PyObject *_wrap_new_Mask(PyObject *, PyObject *args, PyObject *kwargs) {
4917 PyObject *resultobj;
4918 wxBitmap *arg1 = 0 ;
4919 wxColour const &arg2_defvalue = wxNullColour ;
4920 wxColour *arg2 = (wxColour *) &arg2_defvalue ;
4921 wxMask *result;
4922 wxColour temp2 ;
4923 PyObject * obj0 = 0 ;
4924 PyObject * obj1 = 0 ;
4925 char *kwnames[] = {
4926 (char *) "bitmap",(char *) "colour", NULL
4927 };
4928
4929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Mask",kwnames,&obj0,&obj1)) goto fail;
4930 {
4931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4932 if (SWIG_arg_fail(1)) SWIG_fail;
4933 if (arg1 == NULL) {
4934 SWIG_null_ref("wxBitmap");
4935 }
4936 if (SWIG_arg_fail(1)) SWIG_fail;
4937 }
4938 if (obj1) {
4939 {
4940 arg2 = &temp2;
4941 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4942 }
4943 }
4944 {
4945 if (!wxPyCheckForApp()) SWIG_fail;
4946 PyThreadState* __tstate = wxPyBeginAllowThreads();
4947 result = (wxMask *)new_wxMask((wxBitmap const &)*arg1,(wxColour const &)*arg2);
4948
4949 wxPyEndAllowThreads(__tstate);
4950 if (PyErr_Occurred()) SWIG_fail;
4951 }
4952 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 1);
4953 return resultobj;
4954 fail:
4955 return NULL;
4956 }
4957
4958
4959 static PyObject * Mask_swigregister(PyObject *, PyObject *args) {
4960 PyObject *obj;
4961 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4962 SWIG_TypeClientData(SWIGTYPE_p_wxMask, obj);
4963 Py_INCREF(obj);
4964 return Py_BuildValue((char *)"");
4965 }
4966 static PyObject *_wrap_new_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
4967 PyObject *resultobj;
4968 wxString *arg1 = 0 ;
4969 wxBitmapType arg2 ;
4970 int arg3 = (int) -1 ;
4971 int arg4 = (int) -1 ;
4972 wxIcon *result;
4973 bool temp1 = false ;
4974 PyObject * obj0 = 0 ;
4975 PyObject * obj1 = 0 ;
4976 PyObject * obj2 = 0 ;
4977 PyObject * obj3 = 0 ;
4978 char *kwnames[] = {
4979 (char *) "name",(char *) "type",(char *) "desiredWidth",(char *) "desiredHeight", NULL
4980 };
4981
4982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Icon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4983 {
4984 arg1 = wxString_in_helper(obj0);
4985 if (arg1 == NULL) SWIG_fail;
4986 temp1 = true;
4987 }
4988 {
4989 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
4990 if (SWIG_arg_fail(2)) SWIG_fail;
4991 }
4992 if (obj2) {
4993 {
4994 arg3 = (int)(SWIG_As_int(obj2));
4995 if (SWIG_arg_fail(3)) SWIG_fail;
4996 }
4997 }
4998 if (obj3) {
4999 {
5000 arg4 = (int)(SWIG_As_int(obj3));
5001 if (SWIG_arg_fail(4)) SWIG_fail;
5002 }
5003 }
5004 {
5005 if (!wxPyCheckForApp()) SWIG_fail;
5006 PyThreadState* __tstate = wxPyBeginAllowThreads();
5007 result = (wxIcon *)new wxIcon((wxString const &)*arg1,(wxBitmapType )arg2,arg3,arg4);
5008
5009 wxPyEndAllowThreads(__tstate);
5010 if (PyErr_Occurred()) SWIG_fail;
5011 }
5012 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5013 {
5014 if (temp1)
5015 delete arg1;
5016 }
5017 return resultobj;
5018 fail:
5019 {
5020 if (temp1)
5021 delete arg1;
5022 }
5023 return NULL;
5024 }
5025
5026
5027 static PyObject *_wrap_delete_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
5028 PyObject *resultobj;
5029 wxIcon *arg1 = (wxIcon *) 0 ;
5030 PyObject * obj0 = 0 ;
5031 char *kwnames[] = {
5032 (char *) "self", NULL
5033 };
5034
5035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Icon",kwnames,&obj0)) goto fail;
5036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5037 if (SWIG_arg_fail(1)) SWIG_fail;
5038 {
5039 PyThreadState* __tstate = wxPyBeginAllowThreads();
5040 delete arg1;
5041
5042 wxPyEndAllowThreads(__tstate);
5043 if (PyErr_Occurred()) SWIG_fail;
5044 }
5045 Py_INCREF(Py_None); resultobj = Py_None;
5046 return resultobj;
5047 fail:
5048 return NULL;
5049 }
5050
5051
5052 static PyObject *_wrap_new_EmptyIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5053 PyObject *resultobj;
5054 wxIcon *result;
5055 char *kwnames[] = {
5056 NULL
5057 };
5058
5059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EmptyIcon",kwnames)) goto fail;
5060 {
5061 if (!wxPyCheckForApp()) SWIG_fail;
5062 PyThreadState* __tstate = wxPyBeginAllowThreads();
5063 result = (wxIcon *)new wxIcon();
5064
5065 wxPyEndAllowThreads(__tstate);
5066 if (PyErr_Occurred()) SWIG_fail;
5067 }
5068 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5069 return resultobj;
5070 fail:
5071 return NULL;
5072 }
5073
5074
5075 static PyObject *_wrap_new_IconFromLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5076 PyObject *resultobj;
5077 wxIconLocation *arg1 = 0 ;
5078 wxIcon *result;
5079 PyObject * obj0 = 0 ;
5080 char *kwnames[] = {
5081 (char *) "loc", NULL
5082 };
5083
5084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromLocation",kwnames,&obj0)) goto fail;
5085 {
5086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5087 if (SWIG_arg_fail(1)) SWIG_fail;
5088 if (arg1 == NULL) {
5089 SWIG_null_ref("wxIconLocation");
5090 }
5091 if (SWIG_arg_fail(1)) SWIG_fail;
5092 }
5093 {
5094 if (!wxPyCheckForApp()) SWIG_fail;
5095 PyThreadState* __tstate = wxPyBeginAllowThreads();
5096 result = (wxIcon *)new wxIcon((wxIconLocation const &)*arg1);
5097
5098 wxPyEndAllowThreads(__tstate);
5099 if (PyErr_Occurred()) SWIG_fail;
5100 }
5101 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5102 return resultobj;
5103 fail:
5104 return NULL;
5105 }
5106
5107
5108 static PyObject *_wrap_new_IconFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5109 PyObject *resultobj;
5110 wxBitmap *arg1 = 0 ;
5111 wxIcon *result;
5112 PyObject * obj0 = 0 ;
5113 char *kwnames[] = {
5114 (char *) "bmp", NULL
5115 };
5116
5117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromBitmap",kwnames,&obj0)) goto fail;
5118 {
5119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5120 if (SWIG_arg_fail(1)) SWIG_fail;
5121 if (arg1 == NULL) {
5122 SWIG_null_ref("wxBitmap");
5123 }
5124 if (SWIG_arg_fail(1)) SWIG_fail;
5125 }
5126 {
5127 if (!wxPyCheckForApp()) SWIG_fail;
5128 PyThreadState* __tstate = wxPyBeginAllowThreads();
5129 result = (wxIcon *)new_wxIcon((wxBitmap const &)*arg1);
5130
5131 wxPyEndAllowThreads(__tstate);
5132 if (PyErr_Occurred()) SWIG_fail;
5133 }
5134 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5135 return resultobj;
5136 fail:
5137 return NULL;
5138 }
5139
5140
5141 static PyObject *_wrap_new_IconFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
5142 PyObject *resultobj;
5143 PyObject *arg1 = (PyObject *) 0 ;
5144 wxIcon *result;
5145 PyObject * obj0 = 0 ;
5146 char *kwnames[] = {
5147 (char *) "listOfStrings", NULL
5148 };
5149
5150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromXPMData",kwnames,&obj0)) goto fail;
5151 arg1 = obj0;
5152 {
5153 if (!wxPyCheckForApp()) SWIG_fail;
5154 PyThreadState* __tstate = wxPyBeginAllowThreads();
5155 result = (wxIcon *)new_wxIcon(arg1);
5156
5157 wxPyEndAllowThreads(__tstate);
5158 if (PyErr_Occurred()) SWIG_fail;
5159 }
5160 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5161 return resultobj;
5162 fail:
5163 return NULL;
5164 }
5165
5166
5167 static PyObject *_wrap_Icon_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
5168 PyObject *resultobj;
5169 wxIcon *arg1 = (wxIcon *) 0 ;
5170 bool result;
5171 PyObject * obj0 = 0 ;
5172 char *kwnames[] = {
5173 (char *) "self", NULL
5174 };
5175
5176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_Ok",kwnames,&obj0)) goto fail;
5177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5178 if (SWIG_arg_fail(1)) SWIG_fail;
5179 {
5180 PyThreadState* __tstate = wxPyBeginAllowThreads();
5181 result = (bool)(arg1)->Ok();
5182
5183 wxPyEndAllowThreads(__tstate);
5184 if (PyErr_Occurred()) SWIG_fail;
5185 }
5186 {
5187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5188 }
5189 return resultobj;
5190 fail:
5191 return NULL;
5192 }
5193
5194
5195 static PyObject *_wrap_Icon_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5196 PyObject *resultobj;
5197 wxIcon *arg1 = (wxIcon *) 0 ;
5198 int result;
5199 PyObject * obj0 = 0 ;
5200 char *kwnames[] = {
5201 (char *) "self", NULL
5202 };
5203
5204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetWidth",kwnames,&obj0)) goto fail;
5205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5206 if (SWIG_arg_fail(1)) SWIG_fail;
5207 {
5208 PyThreadState* __tstate = wxPyBeginAllowThreads();
5209 result = (int)(arg1)->GetWidth();
5210
5211 wxPyEndAllowThreads(__tstate);
5212 if (PyErr_Occurred()) SWIG_fail;
5213 }
5214 {
5215 resultobj = SWIG_From_int((int)(result));
5216 }
5217 return resultobj;
5218 fail:
5219 return NULL;
5220 }
5221
5222
5223 static PyObject *_wrap_Icon_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5224 PyObject *resultobj;
5225 wxIcon *arg1 = (wxIcon *) 0 ;
5226 int result;
5227 PyObject * obj0 = 0 ;
5228 char *kwnames[] = {
5229 (char *) "self", NULL
5230 };
5231
5232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetHeight",kwnames,&obj0)) goto fail;
5233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5234 if (SWIG_arg_fail(1)) SWIG_fail;
5235 {
5236 PyThreadState* __tstate = wxPyBeginAllowThreads();
5237 result = (int)(arg1)->GetHeight();
5238
5239 wxPyEndAllowThreads(__tstate);
5240 if (PyErr_Occurred()) SWIG_fail;
5241 }
5242 {
5243 resultobj = SWIG_From_int((int)(result));
5244 }
5245 return resultobj;
5246 fail:
5247 return NULL;
5248 }
5249
5250
5251 static PyObject *_wrap_Icon_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5252 PyObject *resultobj;
5253 wxIcon *arg1 = (wxIcon *) 0 ;
5254 int result;
5255 PyObject * obj0 = 0 ;
5256 char *kwnames[] = {
5257 (char *) "self", NULL
5258 };
5259
5260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetDepth",kwnames,&obj0)) goto fail;
5261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5262 if (SWIG_arg_fail(1)) SWIG_fail;
5263 {
5264 PyThreadState* __tstate = wxPyBeginAllowThreads();
5265 result = (int)(arg1)->GetDepth();
5266
5267 wxPyEndAllowThreads(__tstate);
5268 if (PyErr_Occurred()) SWIG_fail;
5269 }
5270 {
5271 resultobj = SWIG_From_int((int)(result));
5272 }
5273 return resultobj;
5274 fail:
5275 return NULL;
5276 }
5277
5278
5279 static PyObject *_wrap_Icon_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5280 PyObject *resultobj;
5281 wxIcon *arg1 = (wxIcon *) 0 ;
5282 int arg2 ;
5283 PyObject * obj0 = 0 ;
5284 PyObject * obj1 = 0 ;
5285 char *kwnames[] = {
5286 (char *) "self",(char *) "w", NULL
5287 };
5288
5289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5291 if (SWIG_arg_fail(1)) SWIG_fail;
5292 {
5293 arg2 = (int)(SWIG_As_int(obj1));
5294 if (SWIG_arg_fail(2)) SWIG_fail;
5295 }
5296 {
5297 PyThreadState* __tstate = wxPyBeginAllowThreads();
5298 (arg1)->SetWidth(arg2);
5299
5300 wxPyEndAllowThreads(__tstate);
5301 if (PyErr_Occurred()) SWIG_fail;
5302 }
5303 Py_INCREF(Py_None); resultobj = Py_None;
5304 return resultobj;
5305 fail:
5306 return NULL;
5307 }
5308
5309
5310 static PyObject *_wrap_Icon_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5311 PyObject *resultobj;
5312 wxIcon *arg1 = (wxIcon *) 0 ;
5313 int arg2 ;
5314 PyObject * obj0 = 0 ;
5315 PyObject * obj1 = 0 ;
5316 char *kwnames[] = {
5317 (char *) "self",(char *) "h", NULL
5318 };
5319
5320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5322 if (SWIG_arg_fail(1)) SWIG_fail;
5323 {
5324 arg2 = (int)(SWIG_As_int(obj1));
5325 if (SWIG_arg_fail(2)) SWIG_fail;
5326 }
5327 {
5328 PyThreadState* __tstate = wxPyBeginAllowThreads();
5329 (arg1)->SetHeight(arg2);
5330
5331 wxPyEndAllowThreads(__tstate);
5332 if (PyErr_Occurred()) SWIG_fail;
5333 }
5334 Py_INCREF(Py_None); resultobj = Py_None;
5335 return resultobj;
5336 fail:
5337 return NULL;
5338 }
5339
5340
5341 static PyObject *_wrap_Icon_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5342 PyObject *resultobj;
5343 wxIcon *arg1 = (wxIcon *) 0 ;
5344 int arg2 ;
5345 PyObject * obj0 = 0 ;
5346 PyObject * obj1 = 0 ;
5347 char *kwnames[] = {
5348 (char *) "self",(char *) "d", NULL
5349 };
5350
5351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetDepth",kwnames,&obj0,&obj1)) goto fail;
5352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5353 if (SWIG_arg_fail(1)) SWIG_fail;
5354 {
5355 arg2 = (int)(SWIG_As_int(obj1));
5356 if (SWIG_arg_fail(2)) SWIG_fail;
5357 }
5358 {
5359 PyThreadState* __tstate = wxPyBeginAllowThreads();
5360 (arg1)->SetDepth(arg2);
5361
5362 wxPyEndAllowThreads(__tstate);
5363 if (PyErr_Occurred()) SWIG_fail;
5364 }
5365 Py_INCREF(Py_None); resultobj = Py_None;
5366 return resultobj;
5367 fail:
5368 return NULL;
5369 }
5370
5371
5372 static PyObject *_wrap_Icon_CopyFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5373 PyObject *resultobj;
5374 wxIcon *arg1 = (wxIcon *) 0 ;
5375 wxBitmap *arg2 = 0 ;
5376 PyObject * obj0 = 0 ;
5377 PyObject * obj1 = 0 ;
5378 char *kwnames[] = {
5379 (char *) "self",(char *) "bmp", NULL
5380 };
5381
5382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_CopyFromBitmap",kwnames,&obj0,&obj1)) goto fail;
5383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5384 if (SWIG_arg_fail(1)) SWIG_fail;
5385 {
5386 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5387 if (SWIG_arg_fail(2)) SWIG_fail;
5388 if (arg2 == NULL) {
5389 SWIG_null_ref("wxBitmap");
5390 }
5391 if (SWIG_arg_fail(2)) SWIG_fail;
5392 }
5393 {
5394 PyThreadState* __tstate = wxPyBeginAllowThreads();
5395 (arg1)->CopyFromBitmap((wxBitmap const &)*arg2);
5396
5397 wxPyEndAllowThreads(__tstate);
5398 if (PyErr_Occurred()) SWIG_fail;
5399 }
5400 Py_INCREF(Py_None); resultobj = Py_None;
5401 return resultobj;
5402 fail:
5403 return NULL;
5404 }
5405
5406
5407 static PyObject * Icon_swigregister(PyObject *, PyObject *args) {
5408 PyObject *obj;
5409 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5410 SWIG_TypeClientData(SWIGTYPE_p_wxIcon, obj);
5411 Py_INCREF(obj);
5412 return Py_BuildValue((char *)"");
5413 }
5414 static PyObject *_wrap_new_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5415 PyObject *resultobj;
5416 wxString *arg1 = (wxString *) &wxPyEmptyString ;
5417 int arg2 = (int) 0 ;
5418 wxIconLocation *result;
5419 bool temp1 = false ;
5420 PyObject * obj0 = 0 ;
5421 PyObject * obj1 = 0 ;
5422 char *kwnames[] = {
5423 (char *) "filename",(char *) "num", NULL
5424 };
5425
5426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconLocation",kwnames,&obj0,&obj1)) goto fail;
5427 if (obj0) {
5428 {
5429 arg1 = wxString_in_helper(obj0);
5430 if (arg1 == NULL) SWIG_fail;
5431 temp1 = true;
5432 }
5433 }
5434 if (obj1) {
5435 {
5436 arg2 = (int)(SWIG_As_int(obj1));
5437 if (SWIG_arg_fail(2)) SWIG_fail;
5438 }
5439 }
5440 {
5441 PyThreadState* __tstate = wxPyBeginAllowThreads();
5442 result = (wxIconLocation *)new_wxIconLocation((wxString const *)arg1,arg2);
5443
5444 wxPyEndAllowThreads(__tstate);
5445 if (PyErr_Occurred()) SWIG_fail;
5446 }
5447 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconLocation, 1);
5448 {
5449 if (temp1)
5450 delete arg1;
5451 }
5452 return resultobj;
5453 fail:
5454 {
5455 if (temp1)
5456 delete arg1;
5457 }
5458 return NULL;
5459 }
5460
5461
5462 static PyObject *_wrap_delete_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5463 PyObject *resultobj;
5464 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5465 PyObject * obj0 = 0 ;
5466 char *kwnames[] = {
5467 (char *) "self", NULL
5468 };
5469
5470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconLocation",kwnames,&obj0)) goto fail;
5471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5472 if (SWIG_arg_fail(1)) SWIG_fail;
5473 {
5474 PyThreadState* __tstate = wxPyBeginAllowThreads();
5475 delete arg1;
5476
5477 wxPyEndAllowThreads(__tstate);
5478 if (PyErr_Occurred()) SWIG_fail;
5479 }
5480 Py_INCREF(Py_None); resultobj = Py_None;
5481 return resultobj;
5482 fail:
5483 return NULL;
5484 }
5485
5486
5487 static PyObject *_wrap_IconLocation_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
5488 PyObject *resultobj;
5489 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5490 bool result;
5491 PyObject * obj0 = 0 ;
5492 char *kwnames[] = {
5493 (char *) "self", NULL
5494 };
5495
5496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_IsOk",kwnames,&obj0)) goto fail;
5497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5498 if (SWIG_arg_fail(1)) SWIG_fail;
5499 {
5500 PyThreadState* __tstate = wxPyBeginAllowThreads();
5501 result = (bool)((wxIconLocation const *)arg1)->IsOk();
5502
5503 wxPyEndAllowThreads(__tstate);
5504 if (PyErr_Occurred()) SWIG_fail;
5505 }
5506 {
5507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5508 }
5509 return resultobj;
5510 fail:
5511 return NULL;
5512 }
5513
5514
5515 static PyObject *_wrap_IconLocation_SetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5516 PyObject *resultobj;
5517 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5518 wxString *arg2 = 0 ;
5519 bool temp2 = false ;
5520 PyObject * obj0 = 0 ;
5521 PyObject * obj1 = 0 ;
5522 char *kwnames[] = {
5523 (char *) "self",(char *) "filename", NULL
5524 };
5525
5526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetFileName",kwnames,&obj0,&obj1)) goto fail;
5527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5528 if (SWIG_arg_fail(1)) SWIG_fail;
5529 {
5530 arg2 = wxString_in_helper(obj1);
5531 if (arg2 == NULL) SWIG_fail;
5532 temp2 = true;
5533 }
5534 {
5535 PyThreadState* __tstate = wxPyBeginAllowThreads();
5536 (arg1)->SetFileName((wxString const &)*arg2);
5537
5538 wxPyEndAllowThreads(__tstate);
5539 if (PyErr_Occurred()) SWIG_fail;
5540 }
5541 Py_INCREF(Py_None); resultobj = Py_None;
5542 {
5543 if (temp2)
5544 delete arg2;
5545 }
5546 return resultobj;
5547 fail:
5548 {
5549 if (temp2)
5550 delete arg2;
5551 }
5552 return NULL;
5553 }
5554
5555
5556 static PyObject *_wrap_IconLocation_GetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5557 PyObject *resultobj;
5558 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5559 wxString *result;
5560 PyObject * obj0 = 0 ;
5561 char *kwnames[] = {
5562 (char *) "self", NULL
5563 };
5564
5565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetFileName",kwnames,&obj0)) goto fail;
5566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5567 if (SWIG_arg_fail(1)) SWIG_fail;
5568 {
5569 PyThreadState* __tstate = wxPyBeginAllowThreads();
5570 {
5571 wxString const &_result_ref = ((wxIconLocation const *)arg1)->GetFileName();
5572 result = (wxString *) &_result_ref;
5573 }
5574
5575 wxPyEndAllowThreads(__tstate);
5576 if (PyErr_Occurred()) SWIG_fail;
5577 }
5578 {
5579 #if wxUSE_UNICODE
5580 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
5581 #else
5582 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
5583 #endif
5584 }
5585 return resultobj;
5586 fail:
5587 return NULL;
5588 }
5589
5590
5591 static PyObject *_wrap_IconLocation_SetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5592 PyObject *resultobj;
5593 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5594 int arg2 ;
5595 PyObject * obj0 = 0 ;
5596 PyObject * obj1 = 0 ;
5597 char *kwnames[] = {
5598 (char *) "self",(char *) "num", NULL
5599 };
5600
5601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetIndex",kwnames,&obj0,&obj1)) goto fail;
5602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5603 if (SWIG_arg_fail(1)) SWIG_fail;
5604 {
5605 arg2 = (int)(SWIG_As_int(obj1));
5606 if (SWIG_arg_fail(2)) SWIG_fail;
5607 }
5608 {
5609 PyThreadState* __tstate = wxPyBeginAllowThreads();
5610 wxIconLocation_SetIndex(arg1,arg2);
5611
5612 wxPyEndAllowThreads(__tstate);
5613 if (PyErr_Occurred()) SWIG_fail;
5614 }
5615 Py_INCREF(Py_None); resultobj = Py_None;
5616 return resultobj;
5617 fail:
5618 return NULL;
5619 }
5620
5621
5622 static PyObject *_wrap_IconLocation_GetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5623 PyObject *resultobj;
5624 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5625 int result;
5626 PyObject * obj0 = 0 ;
5627 char *kwnames[] = {
5628 (char *) "self", NULL
5629 };
5630
5631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetIndex",kwnames,&obj0)) goto fail;
5632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5633 if (SWIG_arg_fail(1)) SWIG_fail;
5634 {
5635 PyThreadState* __tstate = wxPyBeginAllowThreads();
5636 result = (int)wxIconLocation_GetIndex(arg1);
5637
5638 wxPyEndAllowThreads(__tstate);
5639 if (PyErr_Occurred()) SWIG_fail;
5640 }
5641 {
5642 resultobj = SWIG_From_int((int)(result));
5643 }
5644 return resultobj;
5645 fail:
5646 return NULL;
5647 }
5648
5649
5650 static PyObject * IconLocation_swigregister(PyObject *, PyObject *args) {
5651 PyObject *obj;
5652 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5653 SWIG_TypeClientData(SWIGTYPE_p_wxIconLocation, obj);
5654 Py_INCREF(obj);
5655 return Py_BuildValue((char *)"");
5656 }
5657 static PyObject *_wrap_new_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5658 PyObject *resultobj;
5659 wxIconBundle *result;
5660 char *kwnames[] = {
5661 NULL
5662 };
5663
5664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IconBundle",kwnames)) goto fail;
5665 {
5666 PyThreadState* __tstate = wxPyBeginAllowThreads();
5667 result = (wxIconBundle *)new wxIconBundle();
5668
5669 wxPyEndAllowThreads(__tstate);
5670 if (PyErr_Occurred()) SWIG_fail;
5671 }
5672 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5673 return resultobj;
5674 fail:
5675 return NULL;
5676 }
5677
5678
5679 static PyObject *_wrap_new_IconBundleFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5680 PyObject *resultobj;
5681 wxString *arg1 = 0 ;
5682 long arg2 ;
5683 wxIconBundle *result;
5684 bool temp1 = false ;
5685 PyObject * obj0 = 0 ;
5686 PyObject * obj1 = 0 ;
5687 char *kwnames[] = {
5688 (char *) "file",(char *) "type", NULL
5689 };
5690
5691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_IconBundleFromFile",kwnames,&obj0,&obj1)) goto fail;
5692 {
5693 arg1 = wxString_in_helper(obj0);
5694 if (arg1 == NULL) SWIG_fail;
5695 temp1 = true;
5696 }
5697 {
5698 arg2 = (long)(SWIG_As_long(obj1));
5699 if (SWIG_arg_fail(2)) SWIG_fail;
5700 }
5701 {
5702 PyThreadState* __tstate = wxPyBeginAllowThreads();
5703 result = (wxIconBundle *)new wxIconBundle((wxString const &)*arg1,arg2);
5704
5705 wxPyEndAllowThreads(__tstate);
5706 if (PyErr_Occurred()) SWIG_fail;
5707 }
5708 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5709 {
5710 if (temp1)
5711 delete arg1;
5712 }
5713 return resultobj;
5714 fail:
5715 {
5716 if (temp1)
5717 delete arg1;
5718 }
5719 return NULL;
5720 }
5721
5722
5723 static PyObject *_wrap_new_IconBundleFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5724 PyObject *resultobj;
5725 wxIcon *arg1 = 0 ;
5726 wxIconBundle *result;
5727 PyObject * obj0 = 0 ;
5728 char *kwnames[] = {
5729 (char *) "icon", NULL
5730 };
5731
5732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconBundleFromIcon",kwnames,&obj0)) goto fail;
5733 {
5734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5735 if (SWIG_arg_fail(1)) SWIG_fail;
5736 if (arg1 == NULL) {
5737 SWIG_null_ref("wxIcon");
5738 }
5739 if (SWIG_arg_fail(1)) SWIG_fail;
5740 }
5741 {
5742 PyThreadState* __tstate = wxPyBeginAllowThreads();
5743 result = (wxIconBundle *)new wxIconBundle((wxIcon const &)*arg1);
5744
5745 wxPyEndAllowThreads(__tstate);
5746 if (PyErr_Occurred()) SWIG_fail;
5747 }
5748 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5749 return resultobj;
5750 fail:
5751 return NULL;
5752 }
5753
5754
5755 static PyObject *_wrap_delete_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5756 PyObject *resultobj;
5757 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5758 PyObject * obj0 = 0 ;
5759 char *kwnames[] = {
5760 (char *) "self", NULL
5761 };
5762
5763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconBundle",kwnames,&obj0)) goto fail;
5764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5765 if (SWIG_arg_fail(1)) SWIG_fail;
5766 {
5767 PyThreadState* __tstate = wxPyBeginAllowThreads();
5768 delete arg1;
5769
5770 wxPyEndAllowThreads(__tstate);
5771 if (PyErr_Occurred()) SWIG_fail;
5772 }
5773 Py_INCREF(Py_None); resultobj = Py_None;
5774 return resultobj;
5775 fail:
5776 return NULL;
5777 }
5778
5779
5780 static PyObject *_wrap_IconBundle_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5781 PyObject *resultobj;
5782 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5783 wxIcon *arg2 = 0 ;
5784 PyObject * obj0 = 0 ;
5785 PyObject * obj1 = 0 ;
5786 char *kwnames[] = {
5787 (char *) "self",(char *) "icon", NULL
5788 };
5789
5790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_AddIcon",kwnames,&obj0,&obj1)) goto fail;
5791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5792 if (SWIG_arg_fail(1)) SWIG_fail;
5793 {
5794 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5795 if (SWIG_arg_fail(2)) SWIG_fail;
5796 if (arg2 == NULL) {
5797 SWIG_null_ref("wxIcon");
5798 }
5799 if (SWIG_arg_fail(2)) SWIG_fail;
5800 }
5801 {
5802 PyThreadState* __tstate = wxPyBeginAllowThreads();
5803 (arg1)->AddIcon((wxIcon const &)*arg2);
5804
5805 wxPyEndAllowThreads(__tstate);
5806 if (PyErr_Occurred()) SWIG_fail;
5807 }
5808 Py_INCREF(Py_None); resultobj = Py_None;
5809 return resultobj;
5810 fail:
5811 return NULL;
5812 }
5813
5814
5815 static PyObject *_wrap_IconBundle_AddIconFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5816 PyObject *resultobj;
5817 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5818 wxString *arg2 = 0 ;
5819 long arg3 ;
5820 bool temp2 = false ;
5821 PyObject * obj0 = 0 ;
5822 PyObject * obj1 = 0 ;
5823 PyObject * obj2 = 0 ;
5824 char *kwnames[] = {
5825 (char *) "self",(char *) "file",(char *) "type", NULL
5826 };
5827
5828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IconBundle_AddIconFromFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
5829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5830 if (SWIG_arg_fail(1)) SWIG_fail;
5831 {
5832 arg2 = wxString_in_helper(obj1);
5833 if (arg2 == NULL) SWIG_fail;
5834 temp2 = true;
5835 }
5836 {
5837 arg3 = (long)(SWIG_As_long(obj2));
5838 if (SWIG_arg_fail(3)) SWIG_fail;
5839 }
5840 {
5841 PyThreadState* __tstate = wxPyBeginAllowThreads();
5842 (arg1)->AddIcon((wxString const &)*arg2,arg3);
5843
5844 wxPyEndAllowThreads(__tstate);
5845 if (PyErr_Occurred()) SWIG_fail;
5846 }
5847 Py_INCREF(Py_None); resultobj = Py_None;
5848 {
5849 if (temp2)
5850 delete arg2;
5851 }
5852 return resultobj;
5853 fail:
5854 {
5855 if (temp2)
5856 delete arg2;
5857 }
5858 return NULL;
5859 }
5860
5861
5862 static PyObject *_wrap_IconBundle_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5863 PyObject *resultobj;
5864 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5865 wxSize *arg2 = 0 ;
5866 wxIcon *result;
5867 wxSize temp2 ;
5868 PyObject * obj0 = 0 ;
5869 PyObject * obj1 = 0 ;
5870 char *kwnames[] = {
5871 (char *) "self",(char *) "size", NULL
5872 };
5873
5874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_GetIcon",kwnames,&obj0,&obj1)) goto fail;
5875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5876 if (SWIG_arg_fail(1)) SWIG_fail;
5877 {
5878 arg2 = &temp2;
5879 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5880 }
5881 {
5882 PyThreadState* __tstate = wxPyBeginAllowThreads();
5883 {
5884 wxIcon const &_result_ref = ((wxIconBundle const *)arg1)->GetIcon((wxSize const &)*arg2);
5885 result = (wxIcon *) &_result_ref;
5886 }
5887
5888 wxPyEndAllowThreads(__tstate);
5889 if (PyErr_Occurred()) SWIG_fail;
5890 }
5891 {
5892 wxIcon* resultptr = new wxIcon(*result);
5893 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxIcon, 1);
5894 }
5895 return resultobj;
5896 fail:
5897 return NULL;
5898 }
5899
5900
5901 static PyObject * IconBundle_swigregister(PyObject *, PyObject *args) {
5902 PyObject *obj;
5903 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5904 SWIG_TypeClientData(SWIGTYPE_p_wxIconBundle, obj);
5905 Py_INCREF(obj);
5906 return Py_BuildValue((char *)"");
5907 }
5908 static PyObject *_wrap_new_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
5909 PyObject *resultobj;
5910 wxString *arg1 = (wxString *) 0 ;
5911 long arg2 ;
5912 int arg3 = (int) 0 ;
5913 int arg4 = (int) 0 ;
5914 wxCursor *result;
5915 bool temp1 = false ;
5916 PyObject * obj0 = 0 ;
5917 PyObject * obj1 = 0 ;
5918 PyObject * obj2 = 0 ;
5919 PyObject * obj3 = 0 ;
5920 char *kwnames[] = {
5921 (char *) "cursorName",(char *) "type",(char *) "hotSpotX",(char *) "hotSpotY", NULL
5922 };
5923
5924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Cursor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5925 {
5926 arg1 = wxString_in_helper(obj0);
5927 if (arg1 == NULL) SWIG_fail;
5928 temp1 = true;
5929 }
5930 {
5931 arg2 = (long)(SWIG_As_long(obj1));
5932 if (SWIG_arg_fail(2)) SWIG_fail;
5933 }
5934 if (obj2) {
5935 {
5936 arg3 = (int)(SWIG_As_int(obj2));
5937 if (SWIG_arg_fail(3)) SWIG_fail;
5938 }
5939 }
5940 if (obj3) {
5941 {
5942 arg4 = (int)(SWIG_As_int(obj3));
5943 if (SWIG_arg_fail(4)) SWIG_fail;
5944 }
5945 }
5946 {
5947 if (!wxPyCheckForApp()) SWIG_fail;
5948 PyThreadState* __tstate = wxPyBeginAllowThreads();
5949 result = (wxCursor *)new_wxCursor((wxString const *)arg1,arg2,arg3,arg4);
5950
5951 wxPyEndAllowThreads(__tstate);
5952 if (PyErr_Occurred()) SWIG_fail;
5953 }
5954 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
5955 {
5956 if (temp1)
5957 delete arg1;
5958 }
5959 return resultobj;
5960 fail:
5961 {
5962 if (temp1)
5963 delete arg1;
5964 }
5965 return NULL;
5966 }
5967
5968
5969 static PyObject *_wrap_delete_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
5970 PyObject *resultobj;
5971 wxCursor *arg1 = (wxCursor *) 0 ;
5972 PyObject * obj0 = 0 ;
5973 char *kwnames[] = {
5974 (char *) "self", NULL
5975 };
5976
5977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Cursor",kwnames,&obj0)) goto fail;
5978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5979 if (SWIG_arg_fail(1)) SWIG_fail;
5980 {
5981 PyThreadState* __tstate = wxPyBeginAllowThreads();
5982 delete arg1;
5983
5984 wxPyEndAllowThreads(__tstate);
5985 if (PyErr_Occurred()) SWIG_fail;
5986 }
5987 Py_INCREF(Py_None); resultobj = Py_None;
5988 return resultobj;
5989 fail:
5990 return NULL;
5991 }
5992
5993
5994 static PyObject *_wrap_new_StockCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5995 PyObject *resultobj;
5996 int arg1 ;
5997 wxCursor *result;
5998 PyObject * obj0 = 0 ;
5999 char *kwnames[] = {
6000 (char *) "id", NULL
6001 };
6002
6003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_StockCursor",kwnames,&obj0)) goto fail;
6004 {
6005 arg1 = (int)(SWIG_As_int(obj0));
6006 if (SWIG_arg_fail(1)) SWIG_fail;
6007 }
6008 {
6009 if (!wxPyCheckForApp()) SWIG_fail;
6010 PyThreadState* __tstate = wxPyBeginAllowThreads();
6011 result = (wxCursor *)new wxCursor(arg1);
6012
6013 wxPyEndAllowThreads(__tstate);
6014 if (PyErr_Occurred()) SWIG_fail;
6015 }
6016 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6017 return resultobj;
6018 fail:
6019 return NULL;
6020 }
6021
6022
6023 static PyObject *_wrap_new_CursorFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
6024 PyObject *resultobj;
6025 wxImage *arg1 = 0 ;
6026 wxCursor *result;
6027 PyObject * obj0 = 0 ;
6028 char *kwnames[] = {
6029 (char *) "image", NULL
6030 };
6031
6032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CursorFromImage",kwnames,&obj0)) goto fail;
6033 {
6034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
6035 if (SWIG_arg_fail(1)) SWIG_fail;
6036 if (arg1 == NULL) {
6037 SWIG_null_ref("wxImage");
6038 }
6039 if (SWIG_arg_fail(1)) SWIG_fail;
6040 }
6041 {
6042 if (!wxPyCheckForApp()) SWIG_fail;
6043 PyThreadState* __tstate = wxPyBeginAllowThreads();
6044 result = (wxCursor *)new wxCursor((wxImage const &)*arg1);
6045
6046 wxPyEndAllowThreads(__tstate);
6047 if (PyErr_Occurred()) SWIG_fail;
6048 }
6049 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6050 return resultobj;
6051 fail:
6052 return NULL;
6053 }
6054
6055
6056 static PyObject *_wrap_Cursor_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
6057 PyObject *resultobj;
6058 wxCursor *arg1 = (wxCursor *) 0 ;
6059 bool result;
6060 PyObject * obj0 = 0 ;
6061 char *kwnames[] = {
6062 (char *) "self", NULL
6063 };
6064
6065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_Ok",kwnames,&obj0)) goto fail;
6066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6067 if (SWIG_arg_fail(1)) SWIG_fail;
6068 {
6069 PyThreadState* __tstate = wxPyBeginAllowThreads();
6070 result = (bool)(arg1)->Ok();
6071
6072 wxPyEndAllowThreads(__tstate);
6073 if (PyErr_Occurred()) SWIG_fail;
6074 }
6075 {
6076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6077 }
6078 return resultobj;
6079 fail:
6080 return NULL;
6081 }
6082
6083
6084 static PyObject * Cursor_swigregister(PyObject *, PyObject *args) {
6085 PyObject *obj;
6086 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6087 SWIG_TypeClientData(SWIGTYPE_p_wxCursor, obj);
6088 Py_INCREF(obj);
6089 return Py_BuildValue((char *)"");
6090 }
6091 static PyObject *_wrap_new_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6092 PyObject *resultobj;
6093 int arg1 = (int) 0 ;
6094 int arg2 = (int) 0 ;
6095 int arg3 = (int) 0 ;
6096 int arg4 = (int) 0 ;
6097 wxRegion *result;
6098 PyObject * obj0 = 0 ;
6099 PyObject * obj1 = 0 ;
6100 PyObject * obj2 = 0 ;
6101 PyObject * obj3 = 0 ;
6102 char *kwnames[] = {
6103 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6104 };
6105
6106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Region",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6107 if (obj0) {
6108 {
6109 arg1 = (int)(SWIG_As_int(obj0));
6110 if (SWIG_arg_fail(1)) SWIG_fail;
6111 }
6112 }
6113 if (obj1) {
6114 {
6115 arg2 = (int)(SWIG_As_int(obj1));
6116 if (SWIG_arg_fail(2)) SWIG_fail;
6117 }
6118 }
6119 if (obj2) {
6120 {
6121 arg3 = (int)(SWIG_As_int(obj2));
6122 if (SWIG_arg_fail(3)) SWIG_fail;
6123 }
6124 }
6125 if (obj3) {
6126 {
6127 arg4 = (int)(SWIG_As_int(obj3));
6128 if (SWIG_arg_fail(4)) SWIG_fail;
6129 }
6130 }
6131 {
6132 if (!wxPyCheckForApp()) SWIG_fail;
6133 PyThreadState* __tstate = wxPyBeginAllowThreads();
6134 result = (wxRegion *)new wxRegion(arg1,arg2,arg3,arg4);
6135
6136 wxPyEndAllowThreads(__tstate);
6137 if (PyErr_Occurred()) SWIG_fail;
6138 }
6139 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6140 return resultobj;
6141 fail:
6142 return NULL;
6143 }
6144
6145
6146 static PyObject *_wrap_new_RegionFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6147 PyObject *resultobj;
6148 wxBitmap *arg1 = 0 ;
6149 wxRegion *result;
6150 PyObject * obj0 = 0 ;
6151 char *kwnames[] = {
6152 (char *) "bmp", NULL
6153 };
6154
6155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionFromBitmap",kwnames,&obj0)) goto fail;
6156 {
6157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6158 if (SWIG_arg_fail(1)) SWIG_fail;
6159 if (arg1 == NULL) {
6160 SWIG_null_ref("wxBitmap");
6161 }
6162 if (SWIG_arg_fail(1)) SWIG_fail;
6163 }
6164 {
6165 if (!wxPyCheckForApp()) SWIG_fail;
6166 PyThreadState* __tstate = wxPyBeginAllowThreads();
6167 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1);
6168
6169 wxPyEndAllowThreads(__tstate);
6170 if (PyErr_Occurred()) SWIG_fail;
6171 }
6172 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6173 return resultobj;
6174 fail:
6175 return NULL;
6176 }
6177
6178
6179 static PyObject *_wrap_new_RegionFromBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
6180 PyObject *resultobj;
6181 wxBitmap *arg1 = 0 ;
6182 wxColour *arg2 = 0 ;
6183 int arg3 = (int) 0 ;
6184 wxRegion *result;
6185 wxColour temp2 ;
6186 PyObject * obj0 = 0 ;
6187 PyObject * obj1 = 0 ;
6188 PyObject * obj2 = 0 ;
6189 char *kwnames[] = {
6190 (char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
6191 };
6192
6193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_RegionFromBitmapColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
6194 {
6195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6196 if (SWIG_arg_fail(1)) SWIG_fail;
6197 if (arg1 == NULL) {
6198 SWIG_null_ref("wxBitmap");
6199 }
6200 if (SWIG_arg_fail(1)) SWIG_fail;
6201 }
6202 {
6203 arg2 = &temp2;
6204 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6205 }
6206 if (obj2) {
6207 {
6208 arg3 = (int)(SWIG_As_int(obj2));
6209 if (SWIG_arg_fail(3)) SWIG_fail;
6210 }
6211 }
6212 {
6213 if (!wxPyCheckForApp()) SWIG_fail;
6214 PyThreadState* __tstate = wxPyBeginAllowThreads();
6215 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1,(wxColour const &)*arg2,arg3);
6216
6217 wxPyEndAllowThreads(__tstate);
6218 if (PyErr_Occurred()) SWIG_fail;
6219 }
6220 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6221 return resultobj;
6222 fail:
6223 return NULL;
6224 }
6225
6226
6227 static PyObject *_wrap_new_RegionFromPoints(PyObject *, PyObject *args, PyObject *kwargs) {
6228 PyObject *resultobj;
6229 int arg1 ;
6230 wxPoint *arg2 = (wxPoint *) 0 ;
6231 int arg3 = (int) wxWINDING_RULE ;
6232 wxRegion *result;
6233 PyObject * obj0 = 0 ;
6234 PyObject * obj1 = 0 ;
6235 char *kwnames[] = {
6236 (char *) "points",(char *) "fillStyle", NULL
6237 };
6238
6239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_RegionFromPoints",kwnames,&obj0,&obj1)) goto fail;
6240 {
6241 arg2 = wxPoint_LIST_helper(obj0, &arg1);
6242 if (arg2 == NULL) SWIG_fail;
6243 }
6244 if (obj1) {
6245 {
6246 arg3 = (int)(SWIG_As_int(obj1));
6247 if (SWIG_arg_fail(3)) SWIG_fail;
6248 }
6249 }
6250 {
6251 if (!wxPyCheckForApp()) SWIG_fail;
6252 PyThreadState* __tstate = wxPyBeginAllowThreads();
6253 result = (wxRegion *)new wxRegion(arg1,arg2,arg3);
6254
6255 wxPyEndAllowThreads(__tstate);
6256 if (PyErr_Occurred()) SWIG_fail;
6257 }
6258 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6259 {
6260 if (arg2) delete [] arg2;
6261 }
6262 return resultobj;
6263 fail:
6264 {
6265 if (arg2) delete [] arg2;
6266 }
6267 return NULL;
6268 }
6269
6270
6271 static PyObject *_wrap_delete_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6272 PyObject *resultobj;
6273 wxRegion *arg1 = (wxRegion *) 0 ;
6274 PyObject * obj0 = 0 ;
6275 char *kwnames[] = {
6276 (char *) "self", NULL
6277 };
6278
6279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Region",kwnames,&obj0)) goto fail;
6280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6281 if (SWIG_arg_fail(1)) SWIG_fail;
6282 {
6283 PyThreadState* __tstate = wxPyBeginAllowThreads();
6284 delete arg1;
6285
6286 wxPyEndAllowThreads(__tstate);
6287 if (PyErr_Occurred()) SWIG_fail;
6288 }
6289 Py_INCREF(Py_None); resultobj = Py_None;
6290 return resultobj;
6291 fail:
6292 return NULL;
6293 }
6294
6295
6296 static PyObject *_wrap_Region_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
6297 PyObject *resultobj;
6298 wxRegion *arg1 = (wxRegion *) 0 ;
6299 PyObject * obj0 = 0 ;
6300 char *kwnames[] = {
6301 (char *) "self", NULL
6302 };
6303
6304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_Clear",kwnames,&obj0)) goto fail;
6305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6306 if (SWIG_arg_fail(1)) SWIG_fail;
6307 {
6308 PyThreadState* __tstate = wxPyBeginAllowThreads();
6309 (arg1)->Clear();
6310
6311 wxPyEndAllowThreads(__tstate);
6312 if (PyErr_Occurred()) SWIG_fail;
6313 }
6314 Py_INCREF(Py_None); resultobj = Py_None;
6315 return resultobj;
6316 fail:
6317 return NULL;
6318 }
6319
6320
6321 static PyObject *_wrap_Region_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
6322 PyObject *resultobj;
6323 wxRegion *arg1 = (wxRegion *) 0 ;
6324 int arg2 ;
6325 int arg3 ;
6326 bool result;
6327 PyObject * obj0 = 0 ;
6328 PyObject * obj1 = 0 ;
6329 PyObject * obj2 = 0 ;
6330 char *kwnames[] = {
6331 (char *) "self",(char *) "x",(char *) "y", NULL
6332 };
6333
6334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Offset",kwnames,&obj0,&obj1,&obj2)) goto fail;
6335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6336 if (SWIG_arg_fail(1)) SWIG_fail;
6337 {
6338 arg2 = (int)(SWIG_As_int(obj1));
6339 if (SWIG_arg_fail(2)) SWIG_fail;
6340 }
6341 {
6342 arg3 = (int)(SWIG_As_int(obj2));
6343 if (SWIG_arg_fail(3)) SWIG_fail;
6344 }
6345 {
6346 PyThreadState* __tstate = wxPyBeginAllowThreads();
6347 result = (bool)(arg1)->Offset(arg2,arg3);
6348
6349 wxPyEndAllowThreads(__tstate);
6350 if (PyErr_Occurred()) SWIG_fail;
6351 }
6352 {
6353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6354 }
6355 return resultobj;
6356 fail:
6357 return NULL;
6358 }
6359
6360
6361 static PyObject *_wrap_Region_Contains(PyObject *, PyObject *args, PyObject *kwargs) {
6362 PyObject *resultobj;
6363 wxRegion *arg1 = (wxRegion *) 0 ;
6364 int arg2 ;
6365 int arg3 ;
6366 wxRegionContain result;
6367 PyObject * obj0 = 0 ;
6368 PyObject * obj1 = 0 ;
6369 PyObject * obj2 = 0 ;
6370 char *kwnames[] = {
6371 (char *) "self",(char *) "x",(char *) "y", NULL
6372 };
6373
6374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Contains",kwnames,&obj0,&obj1,&obj2)) goto fail;
6375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6376 if (SWIG_arg_fail(1)) SWIG_fail;
6377 {
6378 arg2 = (int)(SWIG_As_int(obj1));
6379 if (SWIG_arg_fail(2)) SWIG_fail;
6380 }
6381 {
6382 arg3 = (int)(SWIG_As_int(obj2));
6383 if (SWIG_arg_fail(3)) SWIG_fail;
6384 }
6385 {
6386 PyThreadState* __tstate = wxPyBeginAllowThreads();
6387 result = (wxRegionContain)(arg1)->Contains(arg2,arg3);
6388
6389 wxPyEndAllowThreads(__tstate);
6390 if (PyErr_Occurred()) SWIG_fail;
6391 }
6392 resultobj = SWIG_From_int((result));
6393 return resultobj;
6394 fail:
6395 return NULL;
6396 }
6397
6398
6399 static PyObject *_wrap_Region_ContainsPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6400 PyObject *resultobj;
6401 wxRegion *arg1 = (wxRegion *) 0 ;
6402 wxPoint *arg2 = 0 ;
6403 wxRegionContain result;
6404 wxPoint temp2 ;
6405 PyObject * obj0 = 0 ;
6406 PyObject * obj1 = 0 ;
6407 char *kwnames[] = {
6408 (char *) "self",(char *) "pt", NULL
6409 };
6410
6411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsPoint",kwnames,&obj0,&obj1)) goto fail;
6412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6413 if (SWIG_arg_fail(1)) SWIG_fail;
6414 {
6415 arg2 = &temp2;
6416 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6417 }
6418 {
6419 PyThreadState* __tstate = wxPyBeginAllowThreads();
6420 result = (wxRegionContain)(arg1)->Contains((wxPoint const &)*arg2);
6421
6422 wxPyEndAllowThreads(__tstate);
6423 if (PyErr_Occurred()) SWIG_fail;
6424 }
6425 resultobj = SWIG_From_int((result));
6426 return resultobj;
6427 fail:
6428 return NULL;
6429 }
6430
6431
6432 static PyObject *_wrap_Region_ContainsRect(PyObject *, PyObject *args, PyObject *kwargs) {
6433 PyObject *resultobj;
6434 wxRegion *arg1 = (wxRegion *) 0 ;
6435 wxRect *arg2 = 0 ;
6436 wxRegionContain result;
6437 wxRect temp2 ;
6438 PyObject * obj0 = 0 ;
6439 PyObject * obj1 = 0 ;
6440 char *kwnames[] = {
6441 (char *) "self",(char *) "rect", NULL
6442 };
6443
6444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsRect",kwnames,&obj0,&obj1)) goto fail;
6445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6446 if (SWIG_arg_fail(1)) SWIG_fail;
6447 {
6448 arg2 = &temp2;
6449 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6450 }
6451 {
6452 PyThreadState* __tstate = wxPyBeginAllowThreads();
6453 result = (wxRegionContain)(arg1)->Contains((wxRect const &)*arg2);
6454
6455 wxPyEndAllowThreads(__tstate);
6456 if (PyErr_Occurred()) SWIG_fail;
6457 }
6458 resultobj = SWIG_From_int((result));
6459 return resultobj;
6460 fail:
6461 return NULL;
6462 }
6463
6464
6465 static PyObject *_wrap_Region_ContainsRectDim(PyObject *, PyObject *args, PyObject *kwargs) {
6466 PyObject *resultobj;
6467 wxRegion *arg1 = (wxRegion *) 0 ;
6468 int arg2 ;
6469 int arg3 ;
6470 int arg4 ;
6471 int arg5 ;
6472 wxRegionContain result;
6473 PyObject * obj0 = 0 ;
6474 PyObject * obj1 = 0 ;
6475 PyObject * obj2 = 0 ;
6476 PyObject * obj3 = 0 ;
6477 PyObject * obj4 = 0 ;
6478 char *kwnames[] = {
6479 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
6480 };
6481
6482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_ContainsRectDim",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6484 if (SWIG_arg_fail(1)) SWIG_fail;
6485 {
6486 arg2 = (int)(SWIG_As_int(obj1));
6487 if (SWIG_arg_fail(2)) SWIG_fail;
6488 }
6489 {
6490 arg3 = (int)(SWIG_As_int(obj2));
6491 if (SWIG_arg_fail(3)) SWIG_fail;
6492 }
6493 {
6494 arg4 = (int)(SWIG_As_int(obj3));
6495 if (SWIG_arg_fail(4)) SWIG_fail;
6496 }
6497 {
6498 arg5 = (int)(SWIG_As_int(obj4));
6499 if (SWIG_arg_fail(5)) SWIG_fail;
6500 }
6501 {
6502 PyThreadState* __tstate = wxPyBeginAllowThreads();
6503 result = (wxRegionContain)(arg1)->Contains(arg2,arg3,arg4,arg5);
6504
6505 wxPyEndAllowThreads(__tstate);
6506 if (PyErr_Occurred()) SWIG_fail;
6507 }
6508 resultobj = SWIG_From_int((result));
6509 return resultobj;
6510 fail:
6511 return NULL;
6512 }
6513
6514
6515 static PyObject *_wrap_Region_GetBox(PyObject *, PyObject *args, PyObject *kwargs) {
6516 PyObject *resultobj;
6517 wxRegion *arg1 = (wxRegion *) 0 ;
6518 wxRect result;
6519 PyObject * obj0 = 0 ;
6520 char *kwnames[] = {
6521 (char *) "self", NULL
6522 };
6523
6524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_GetBox",kwnames,&obj0)) goto fail;
6525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6526 if (SWIG_arg_fail(1)) SWIG_fail;
6527 {
6528 PyThreadState* __tstate = wxPyBeginAllowThreads();
6529 result = (arg1)->GetBox();
6530
6531 wxPyEndAllowThreads(__tstate);
6532 if (PyErr_Occurred()) SWIG_fail;
6533 }
6534 {
6535 wxRect * resultptr;
6536 resultptr = new wxRect((wxRect &)(result));
6537 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6538 }
6539 return resultobj;
6540 fail:
6541 return NULL;
6542 }
6543
6544
6545 static PyObject *_wrap_Region_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
6546 PyObject *resultobj;
6547 wxRegion *arg1 = (wxRegion *) 0 ;
6548 int arg2 ;
6549 int arg3 ;
6550 int arg4 ;
6551 int arg5 ;
6552 bool result;
6553 PyObject * obj0 = 0 ;
6554 PyObject * obj1 = 0 ;
6555 PyObject * obj2 = 0 ;
6556 PyObject * obj3 = 0 ;
6557 PyObject * obj4 = 0 ;
6558 char *kwnames[] = {
6559 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6560 };
6561
6562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Intersect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6564 if (SWIG_arg_fail(1)) SWIG_fail;
6565 {
6566 arg2 = (int)(SWIG_As_int(obj1));
6567 if (SWIG_arg_fail(2)) SWIG_fail;
6568 }
6569 {
6570 arg3 = (int)(SWIG_As_int(obj2));
6571 if (SWIG_arg_fail(3)) SWIG_fail;
6572 }
6573 {
6574 arg4 = (int)(SWIG_As_int(obj3));
6575 if (SWIG_arg_fail(4)) SWIG_fail;
6576 }
6577 {
6578 arg5 = (int)(SWIG_As_int(obj4));
6579 if (SWIG_arg_fail(5)) SWIG_fail;
6580 }
6581 {
6582 PyThreadState* __tstate = wxPyBeginAllowThreads();
6583 result = (bool)(arg1)->Intersect(arg2,arg3,arg4,arg5);
6584
6585 wxPyEndAllowThreads(__tstate);
6586 if (PyErr_Occurred()) SWIG_fail;
6587 }
6588 {
6589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6590 }
6591 return resultobj;
6592 fail:
6593 return NULL;
6594 }
6595
6596
6597 static PyObject *_wrap_Region_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6598 PyObject *resultobj;
6599 wxRegion *arg1 = (wxRegion *) 0 ;
6600 wxRect *arg2 = 0 ;
6601 bool result;
6602 wxRect temp2 ;
6603 PyObject * obj0 = 0 ;
6604 PyObject * obj1 = 0 ;
6605 char *kwnames[] = {
6606 (char *) "self",(char *) "rect", NULL
6607 };
6608
6609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6611 if (SWIG_arg_fail(1)) SWIG_fail;
6612 {
6613 arg2 = &temp2;
6614 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6615 }
6616 {
6617 PyThreadState* __tstate = wxPyBeginAllowThreads();
6618 result = (bool)(arg1)->Intersect((wxRect const &)*arg2);
6619
6620 wxPyEndAllowThreads(__tstate);
6621 if (PyErr_Occurred()) SWIG_fail;
6622 }
6623 {
6624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6625 }
6626 return resultobj;
6627 fail:
6628 return NULL;
6629 }
6630
6631
6632 static PyObject *_wrap_Region_IntersectRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6633 PyObject *resultobj;
6634 wxRegion *arg1 = (wxRegion *) 0 ;
6635 wxRegion *arg2 = 0 ;
6636 bool result;
6637 PyObject * obj0 = 0 ;
6638 PyObject * obj1 = 0 ;
6639 char *kwnames[] = {
6640 (char *) "self",(char *) "region", NULL
6641 };
6642
6643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRegion",kwnames,&obj0,&obj1)) goto fail;
6644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6645 if (SWIG_arg_fail(1)) SWIG_fail;
6646 {
6647 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6648 if (SWIG_arg_fail(2)) SWIG_fail;
6649 if (arg2 == NULL) {
6650 SWIG_null_ref("wxRegion");
6651 }
6652 if (SWIG_arg_fail(2)) SWIG_fail;
6653 }
6654 {
6655 PyThreadState* __tstate = wxPyBeginAllowThreads();
6656 result = (bool)(arg1)->Intersect((wxRegion const &)*arg2);
6657
6658 wxPyEndAllowThreads(__tstate);
6659 if (PyErr_Occurred()) SWIG_fail;
6660 }
6661 {
6662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6663 }
6664 return resultobj;
6665 fail:
6666 return NULL;
6667 }
6668
6669
6670 static PyObject *_wrap_Region_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
6671 PyObject *resultobj;
6672 wxRegion *arg1 = (wxRegion *) 0 ;
6673 bool result;
6674 PyObject * obj0 = 0 ;
6675 char *kwnames[] = {
6676 (char *) "self", NULL
6677 };
6678
6679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_IsEmpty",kwnames,&obj0)) goto fail;
6680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6681 if (SWIG_arg_fail(1)) SWIG_fail;
6682 {
6683 PyThreadState* __tstate = wxPyBeginAllowThreads();
6684 result = (bool)(arg1)->IsEmpty();
6685
6686 wxPyEndAllowThreads(__tstate);
6687 if (PyErr_Occurred()) SWIG_fail;
6688 }
6689 {
6690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6691 }
6692 return resultobj;
6693 fail:
6694 return NULL;
6695 }
6696
6697
6698 static PyObject *_wrap_Region_Union(PyObject *, PyObject *args, PyObject *kwargs) {
6699 PyObject *resultobj;
6700 wxRegion *arg1 = (wxRegion *) 0 ;
6701 int arg2 ;
6702 int arg3 ;
6703 int arg4 ;
6704 int arg5 ;
6705 bool result;
6706 PyObject * obj0 = 0 ;
6707 PyObject * obj1 = 0 ;
6708 PyObject * obj2 = 0 ;
6709 PyObject * obj3 = 0 ;
6710 PyObject * obj4 = 0 ;
6711 char *kwnames[] = {
6712 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6713 };
6714
6715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Union",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6717 if (SWIG_arg_fail(1)) SWIG_fail;
6718 {
6719 arg2 = (int)(SWIG_As_int(obj1));
6720 if (SWIG_arg_fail(2)) SWIG_fail;
6721 }
6722 {
6723 arg3 = (int)(SWIG_As_int(obj2));
6724 if (SWIG_arg_fail(3)) SWIG_fail;
6725 }
6726 {
6727 arg4 = (int)(SWIG_As_int(obj3));
6728 if (SWIG_arg_fail(4)) SWIG_fail;
6729 }
6730 {
6731 arg5 = (int)(SWIG_As_int(obj4));
6732 if (SWIG_arg_fail(5)) SWIG_fail;
6733 }
6734 {
6735 PyThreadState* __tstate = wxPyBeginAllowThreads();
6736 result = (bool)(arg1)->Union(arg2,arg3,arg4,arg5);
6737
6738 wxPyEndAllowThreads(__tstate);
6739 if (PyErr_Occurred()) SWIG_fail;
6740 }
6741 {
6742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6743 }
6744 return resultobj;
6745 fail:
6746 return NULL;
6747 }
6748
6749
6750 static PyObject *_wrap_Region_UnionRect(PyObject *, PyObject *args, PyObject *kwargs) {
6751 PyObject *resultobj;
6752 wxRegion *arg1 = (wxRegion *) 0 ;
6753 wxRect *arg2 = 0 ;
6754 bool result;
6755 wxRect temp2 ;
6756 PyObject * obj0 = 0 ;
6757 PyObject * obj1 = 0 ;
6758 char *kwnames[] = {
6759 (char *) "self",(char *) "rect", NULL
6760 };
6761
6762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRect",kwnames,&obj0,&obj1)) goto fail;
6763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6764 if (SWIG_arg_fail(1)) SWIG_fail;
6765 {
6766 arg2 = &temp2;
6767 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6768 }
6769 {
6770 PyThreadState* __tstate = wxPyBeginAllowThreads();
6771 result = (bool)(arg1)->Union((wxRect const &)*arg2);
6772
6773 wxPyEndAllowThreads(__tstate);
6774 if (PyErr_Occurred()) SWIG_fail;
6775 }
6776 {
6777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6778 }
6779 return resultobj;
6780 fail:
6781 return NULL;
6782 }
6783
6784
6785 static PyObject *_wrap_Region_UnionRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6786 PyObject *resultobj;
6787 wxRegion *arg1 = (wxRegion *) 0 ;
6788 wxRegion *arg2 = 0 ;
6789 bool result;
6790 PyObject * obj0 = 0 ;
6791 PyObject * obj1 = 0 ;
6792 char *kwnames[] = {
6793 (char *) "self",(char *) "region", NULL
6794 };
6795
6796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRegion",kwnames,&obj0,&obj1)) goto fail;
6797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6798 if (SWIG_arg_fail(1)) SWIG_fail;
6799 {
6800 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6801 if (SWIG_arg_fail(2)) SWIG_fail;
6802 if (arg2 == NULL) {
6803 SWIG_null_ref("wxRegion");
6804 }
6805 if (SWIG_arg_fail(2)) SWIG_fail;
6806 }
6807 {
6808 PyThreadState* __tstate = wxPyBeginAllowThreads();
6809 result = (bool)(arg1)->Union((wxRegion const &)*arg2);
6810
6811 wxPyEndAllowThreads(__tstate);
6812 if (PyErr_Occurred()) SWIG_fail;
6813 }
6814 {
6815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6816 }
6817 return resultobj;
6818 fail:
6819 return NULL;
6820 }
6821
6822
6823 static PyObject *_wrap_Region_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
6824 PyObject *resultobj;
6825 wxRegion *arg1 = (wxRegion *) 0 ;
6826 int arg2 ;
6827 int arg3 ;
6828 int arg4 ;
6829 int arg5 ;
6830 bool result;
6831 PyObject * obj0 = 0 ;
6832 PyObject * obj1 = 0 ;
6833 PyObject * obj2 = 0 ;
6834 PyObject * obj3 = 0 ;
6835 PyObject * obj4 = 0 ;
6836 char *kwnames[] = {
6837 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6838 };
6839
6840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Subtract",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6842 if (SWIG_arg_fail(1)) SWIG_fail;
6843 {
6844 arg2 = (int)(SWIG_As_int(obj1));
6845 if (SWIG_arg_fail(2)) SWIG_fail;
6846 }
6847 {
6848 arg3 = (int)(SWIG_As_int(obj2));
6849 if (SWIG_arg_fail(3)) SWIG_fail;
6850 }
6851 {
6852 arg4 = (int)(SWIG_As_int(obj3));
6853 if (SWIG_arg_fail(4)) SWIG_fail;
6854 }
6855 {
6856 arg5 = (int)(SWIG_As_int(obj4));
6857 if (SWIG_arg_fail(5)) SWIG_fail;
6858 }
6859 {
6860 PyThreadState* __tstate = wxPyBeginAllowThreads();
6861 result = (bool)(arg1)->Subtract(arg2,arg3,arg4,arg5);
6862
6863 wxPyEndAllowThreads(__tstate);
6864 if (PyErr_Occurred()) SWIG_fail;
6865 }
6866 {
6867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6868 }
6869 return resultobj;
6870 fail:
6871 return NULL;
6872 }
6873
6874
6875 static PyObject *_wrap_Region_SubtractRect(PyObject *, PyObject *args, PyObject *kwargs) {
6876 PyObject *resultobj;
6877 wxRegion *arg1 = (wxRegion *) 0 ;
6878 wxRect *arg2 = 0 ;
6879 bool result;
6880 wxRect temp2 ;
6881 PyObject * obj0 = 0 ;
6882 PyObject * obj1 = 0 ;
6883 char *kwnames[] = {
6884 (char *) "self",(char *) "rect", NULL
6885 };
6886
6887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRect",kwnames,&obj0,&obj1)) goto fail;
6888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6889 if (SWIG_arg_fail(1)) SWIG_fail;
6890 {
6891 arg2 = &temp2;
6892 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6893 }
6894 {
6895 PyThreadState* __tstate = wxPyBeginAllowThreads();
6896 result = (bool)(arg1)->Subtract((wxRect const &)*arg2);
6897
6898 wxPyEndAllowThreads(__tstate);
6899 if (PyErr_Occurred()) SWIG_fail;
6900 }
6901 {
6902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6903 }
6904 return resultobj;
6905 fail:
6906 return NULL;
6907 }
6908
6909
6910 static PyObject *_wrap_Region_SubtractRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6911 PyObject *resultobj;
6912 wxRegion *arg1 = (wxRegion *) 0 ;
6913 wxRegion *arg2 = 0 ;
6914 bool result;
6915 PyObject * obj0 = 0 ;
6916 PyObject * obj1 = 0 ;
6917 char *kwnames[] = {
6918 (char *) "self",(char *) "region", NULL
6919 };
6920
6921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRegion",kwnames,&obj0,&obj1)) goto fail;
6922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6923 if (SWIG_arg_fail(1)) SWIG_fail;
6924 {
6925 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6926 if (SWIG_arg_fail(2)) SWIG_fail;
6927 if (arg2 == NULL) {
6928 SWIG_null_ref("wxRegion");
6929 }
6930 if (SWIG_arg_fail(2)) SWIG_fail;
6931 }
6932 {
6933 PyThreadState* __tstate = wxPyBeginAllowThreads();
6934 result = (bool)(arg1)->Subtract((wxRegion const &)*arg2);
6935
6936 wxPyEndAllowThreads(__tstate);
6937 if (PyErr_Occurred()) SWIG_fail;
6938 }
6939 {
6940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6941 }
6942 return resultobj;
6943 fail:
6944 return NULL;
6945 }
6946
6947
6948 static PyObject *_wrap_Region_Xor(PyObject *, PyObject *args, PyObject *kwargs) {
6949 PyObject *resultobj;
6950 wxRegion *arg1 = (wxRegion *) 0 ;
6951 int arg2 ;
6952 int arg3 ;
6953 int arg4 ;
6954 int arg5 ;
6955 bool result;
6956 PyObject * obj0 = 0 ;
6957 PyObject * obj1 = 0 ;
6958 PyObject * obj2 = 0 ;
6959 PyObject * obj3 = 0 ;
6960 PyObject * obj4 = 0 ;
6961 char *kwnames[] = {
6962 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6963 };
6964
6965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Xor",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6967 if (SWIG_arg_fail(1)) SWIG_fail;
6968 {
6969 arg2 = (int)(SWIG_As_int(obj1));
6970 if (SWIG_arg_fail(2)) SWIG_fail;
6971 }
6972 {
6973 arg3 = (int)(SWIG_As_int(obj2));
6974 if (SWIG_arg_fail(3)) SWIG_fail;
6975 }
6976 {
6977 arg4 = (int)(SWIG_As_int(obj3));
6978 if (SWIG_arg_fail(4)) SWIG_fail;
6979 }
6980 {
6981 arg5 = (int)(SWIG_As_int(obj4));
6982 if (SWIG_arg_fail(5)) SWIG_fail;
6983 }
6984 {
6985 PyThreadState* __tstate = wxPyBeginAllowThreads();
6986 result = (bool)(arg1)->Xor(arg2,arg3,arg4,arg5);
6987
6988 wxPyEndAllowThreads(__tstate);
6989 if (PyErr_Occurred()) SWIG_fail;
6990 }
6991 {
6992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6993 }
6994 return resultobj;
6995 fail:
6996 return NULL;
6997 }
6998
6999
7000 static PyObject *_wrap_Region_XorRect(PyObject *, PyObject *args, PyObject *kwargs) {
7001 PyObject *resultobj;
7002 wxRegion *arg1 = (wxRegion *) 0 ;
7003 wxRect *arg2 = 0 ;
7004 bool result;
7005 wxRect temp2 ;
7006 PyObject * obj0 = 0 ;
7007 PyObject * obj1 = 0 ;
7008 char *kwnames[] = {
7009 (char *) "self",(char *) "rect", NULL
7010 };
7011
7012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRect",kwnames,&obj0,&obj1)) goto fail;
7013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7014 if (SWIG_arg_fail(1)) SWIG_fail;
7015 {
7016 arg2 = &temp2;
7017 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7018 }
7019 {
7020 PyThreadState* __tstate = wxPyBeginAllowThreads();
7021 result = (bool)(arg1)->Xor((wxRect const &)*arg2);
7022
7023 wxPyEndAllowThreads(__tstate);
7024 if (PyErr_Occurred()) SWIG_fail;
7025 }
7026 {
7027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7028 }
7029 return resultobj;
7030 fail:
7031 return NULL;
7032 }
7033
7034
7035 static PyObject *_wrap_Region_XorRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7036 PyObject *resultobj;
7037 wxRegion *arg1 = (wxRegion *) 0 ;
7038 wxRegion *arg2 = 0 ;
7039 bool result;
7040 PyObject * obj0 = 0 ;
7041 PyObject * obj1 = 0 ;
7042 char *kwnames[] = {
7043 (char *) "self",(char *) "region", NULL
7044 };
7045
7046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRegion",kwnames,&obj0,&obj1)) goto fail;
7047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7048 if (SWIG_arg_fail(1)) SWIG_fail;
7049 {
7050 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7051 if (SWIG_arg_fail(2)) SWIG_fail;
7052 if (arg2 == NULL) {
7053 SWIG_null_ref("wxRegion");
7054 }
7055 if (SWIG_arg_fail(2)) SWIG_fail;
7056 }
7057 {
7058 PyThreadState* __tstate = wxPyBeginAllowThreads();
7059 result = (bool)(arg1)->Xor((wxRegion const &)*arg2);
7060
7061 wxPyEndAllowThreads(__tstate);
7062 if (PyErr_Occurred()) SWIG_fail;
7063 }
7064 {
7065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7066 }
7067 return resultobj;
7068 fail:
7069 return NULL;
7070 }
7071
7072
7073 static PyObject *_wrap_Region_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7074 PyObject *resultobj;
7075 wxRegion *arg1 = (wxRegion *) 0 ;
7076 SwigValueWrapper<wxBitmap > result;
7077 PyObject * obj0 = 0 ;
7078 char *kwnames[] = {
7079 (char *) "self", NULL
7080 };
7081
7082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_ConvertToBitmap",kwnames,&obj0)) goto fail;
7083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7084 if (SWIG_arg_fail(1)) SWIG_fail;
7085 {
7086 PyThreadState* __tstate = wxPyBeginAllowThreads();
7087 result = (arg1)->ConvertToBitmap();
7088
7089 wxPyEndAllowThreads(__tstate);
7090 if (PyErr_Occurred()) SWIG_fail;
7091 }
7092 {
7093 wxBitmap * resultptr;
7094 resultptr = new wxBitmap((wxBitmap &)(result));
7095 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
7096 }
7097 return resultobj;
7098 fail:
7099 return NULL;
7100 }
7101
7102
7103 static PyObject *_wrap_Region_UnionBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7104 PyObject *resultobj;
7105 wxRegion *arg1 = (wxRegion *) 0 ;
7106 wxBitmap *arg2 = 0 ;
7107 bool result;
7108 PyObject * obj0 = 0 ;
7109 PyObject * obj1 = 0 ;
7110 char *kwnames[] = {
7111 (char *) "self",(char *) "bmp", NULL
7112 };
7113
7114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionBitmap",kwnames,&obj0,&obj1)) goto fail;
7115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7116 if (SWIG_arg_fail(1)) SWIG_fail;
7117 {
7118 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7119 if (SWIG_arg_fail(2)) SWIG_fail;
7120 if (arg2 == NULL) {
7121 SWIG_null_ref("wxBitmap");
7122 }
7123 if (SWIG_arg_fail(2)) SWIG_fail;
7124 }
7125 {
7126 PyThreadState* __tstate = wxPyBeginAllowThreads();
7127 result = (bool)(arg1)->Union((wxBitmap const &)*arg2);
7128
7129 wxPyEndAllowThreads(__tstate);
7130 if (PyErr_Occurred()) SWIG_fail;
7131 }
7132 {
7133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7134 }
7135 return resultobj;
7136 fail:
7137 return NULL;
7138 }
7139
7140
7141 static PyObject *_wrap_Region_UnionBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
7142 PyObject *resultobj;
7143 wxRegion *arg1 = (wxRegion *) 0 ;
7144 wxBitmap *arg2 = 0 ;
7145 wxColour *arg3 = 0 ;
7146 int arg4 = (int) 0 ;
7147 bool result;
7148 wxColour temp3 ;
7149 PyObject * obj0 = 0 ;
7150 PyObject * obj1 = 0 ;
7151 PyObject * obj2 = 0 ;
7152 PyObject * obj3 = 0 ;
7153 char *kwnames[] = {
7154 (char *) "self",(char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
7155 };
7156
7157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Region_UnionBitmapColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7159 if (SWIG_arg_fail(1)) SWIG_fail;
7160 {
7161 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7162 if (SWIG_arg_fail(2)) SWIG_fail;
7163 if (arg2 == NULL) {
7164 SWIG_null_ref("wxBitmap");
7165 }
7166 if (SWIG_arg_fail(2)) SWIG_fail;
7167 }
7168 {
7169 arg3 = &temp3;
7170 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
7171 }
7172 if (obj3) {
7173 {
7174 arg4 = (int)(SWIG_As_int(obj3));
7175 if (SWIG_arg_fail(4)) SWIG_fail;
7176 }
7177 }
7178 {
7179 PyThreadState* __tstate = wxPyBeginAllowThreads();
7180 result = (bool)(arg1)->Union((wxBitmap const &)*arg2,(wxColour const &)*arg3,arg4);
7181
7182 wxPyEndAllowThreads(__tstate);
7183 if (PyErr_Occurred()) SWIG_fail;
7184 }
7185 {
7186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7187 }
7188 return resultobj;
7189 fail:
7190 return NULL;
7191 }
7192
7193
7194 static PyObject * Region_swigregister(PyObject *, PyObject *args) {
7195 PyObject *obj;
7196 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7197 SWIG_TypeClientData(SWIGTYPE_p_wxRegion, obj);
7198 Py_INCREF(obj);
7199 return Py_BuildValue((char *)"");
7200 }
7201 static PyObject *_wrap_new_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7202 PyObject *resultobj;
7203 wxRegion *arg1 = 0 ;
7204 wxRegionIterator *result;
7205 PyObject * obj0 = 0 ;
7206 char *kwnames[] = {
7207 (char *) "region", NULL
7208 };
7209
7210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionIterator",kwnames,&obj0)) goto fail;
7211 {
7212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7213 if (SWIG_arg_fail(1)) SWIG_fail;
7214 if (arg1 == NULL) {
7215 SWIG_null_ref("wxRegion");
7216 }
7217 if (SWIG_arg_fail(1)) SWIG_fail;
7218 }
7219 {
7220 if (!wxPyCheckForApp()) SWIG_fail;
7221 PyThreadState* __tstate = wxPyBeginAllowThreads();
7222 result = (wxRegionIterator *)new wxRegionIterator((wxRegion const &)*arg1);
7223
7224 wxPyEndAllowThreads(__tstate);
7225 if (PyErr_Occurred()) SWIG_fail;
7226 }
7227 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegionIterator, 1);
7228 return resultobj;
7229 fail:
7230 return NULL;
7231 }
7232
7233
7234 static PyObject *_wrap_delete_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7235 PyObject *resultobj;
7236 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7237 PyObject * obj0 = 0 ;
7238 char *kwnames[] = {
7239 (char *) "self", NULL
7240 };
7241
7242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RegionIterator",kwnames,&obj0)) goto fail;
7243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7244 if (SWIG_arg_fail(1)) SWIG_fail;
7245 {
7246 PyThreadState* __tstate = wxPyBeginAllowThreads();
7247 delete arg1;
7248
7249 wxPyEndAllowThreads(__tstate);
7250 if (PyErr_Occurred()) SWIG_fail;
7251 }
7252 Py_INCREF(Py_None); resultobj = Py_None;
7253 return resultobj;
7254 fail:
7255 return NULL;
7256 }
7257
7258
7259 static PyObject *_wrap_RegionIterator_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
7260 PyObject *resultobj;
7261 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7262 int result;
7263 PyObject * obj0 = 0 ;
7264 char *kwnames[] = {
7265 (char *) "self", NULL
7266 };
7267
7268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetX",kwnames,&obj0)) goto fail;
7269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7270 if (SWIG_arg_fail(1)) SWIG_fail;
7271 {
7272 PyThreadState* __tstate = wxPyBeginAllowThreads();
7273 result = (int)(arg1)->GetX();
7274
7275 wxPyEndAllowThreads(__tstate);
7276 if (PyErr_Occurred()) SWIG_fail;
7277 }
7278 {
7279 resultobj = SWIG_From_int((int)(result));
7280 }
7281 return resultobj;
7282 fail:
7283 return NULL;
7284 }
7285
7286
7287 static PyObject *_wrap_RegionIterator_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
7288 PyObject *resultobj;
7289 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7290 int result;
7291 PyObject * obj0 = 0 ;
7292 char *kwnames[] = {
7293 (char *) "self", NULL
7294 };
7295
7296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetY",kwnames,&obj0)) goto fail;
7297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7298 if (SWIG_arg_fail(1)) SWIG_fail;
7299 {
7300 PyThreadState* __tstate = wxPyBeginAllowThreads();
7301 result = (int)(arg1)->GetY();
7302
7303 wxPyEndAllowThreads(__tstate);
7304 if (PyErr_Occurred()) SWIG_fail;
7305 }
7306 {
7307 resultobj = SWIG_From_int((int)(result));
7308 }
7309 return resultobj;
7310 fail:
7311 return NULL;
7312 }
7313
7314
7315 static PyObject *_wrap_RegionIterator_GetW(PyObject *, PyObject *args, PyObject *kwargs) {
7316 PyObject *resultobj;
7317 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7318 int result;
7319 PyObject * obj0 = 0 ;
7320 char *kwnames[] = {
7321 (char *) "self", NULL
7322 };
7323
7324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetW",kwnames,&obj0)) goto fail;
7325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7326 if (SWIG_arg_fail(1)) SWIG_fail;
7327 {
7328 PyThreadState* __tstate = wxPyBeginAllowThreads();
7329 result = (int)(arg1)->GetW();
7330
7331 wxPyEndAllowThreads(__tstate);
7332 if (PyErr_Occurred()) SWIG_fail;
7333 }
7334 {
7335 resultobj = SWIG_From_int((int)(result));
7336 }
7337 return resultobj;
7338 fail:
7339 return NULL;
7340 }
7341
7342
7343 static PyObject *_wrap_RegionIterator_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
7344 PyObject *resultobj;
7345 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7346 int result;
7347 PyObject * obj0 = 0 ;
7348 char *kwnames[] = {
7349 (char *) "self", NULL
7350 };
7351
7352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetWidth",kwnames,&obj0)) goto fail;
7353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7354 if (SWIG_arg_fail(1)) SWIG_fail;
7355 {
7356 PyThreadState* __tstate = wxPyBeginAllowThreads();
7357 result = (int)(arg1)->GetWidth();
7358
7359 wxPyEndAllowThreads(__tstate);
7360 if (PyErr_Occurred()) SWIG_fail;
7361 }
7362 {
7363 resultobj = SWIG_From_int((int)(result));
7364 }
7365 return resultobj;
7366 fail:
7367 return NULL;
7368 }
7369
7370
7371 static PyObject *_wrap_RegionIterator_GetH(PyObject *, PyObject *args, PyObject *kwargs) {
7372 PyObject *resultobj;
7373 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7374 int result;
7375 PyObject * obj0 = 0 ;
7376 char *kwnames[] = {
7377 (char *) "self", NULL
7378 };
7379
7380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetH",kwnames,&obj0)) goto fail;
7381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7382 if (SWIG_arg_fail(1)) SWIG_fail;
7383 {
7384 PyThreadState* __tstate = wxPyBeginAllowThreads();
7385 result = (int)(arg1)->GetH();
7386
7387 wxPyEndAllowThreads(__tstate);
7388 if (PyErr_Occurred()) SWIG_fail;
7389 }
7390 {
7391 resultobj = SWIG_From_int((int)(result));
7392 }
7393 return resultobj;
7394 fail:
7395 return NULL;
7396 }
7397
7398
7399 static PyObject *_wrap_RegionIterator_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
7400 PyObject *resultobj;
7401 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7402 int result;
7403 PyObject * obj0 = 0 ;
7404 char *kwnames[] = {
7405 (char *) "self", NULL
7406 };
7407
7408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetHeight",kwnames,&obj0)) goto fail;
7409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7410 if (SWIG_arg_fail(1)) SWIG_fail;
7411 {
7412 PyThreadState* __tstate = wxPyBeginAllowThreads();
7413 result = (int)(arg1)->GetHeight();
7414
7415 wxPyEndAllowThreads(__tstate);
7416 if (PyErr_Occurred()) SWIG_fail;
7417 }
7418 {
7419 resultobj = SWIG_From_int((int)(result));
7420 }
7421 return resultobj;
7422 fail:
7423 return NULL;
7424 }
7425
7426
7427 static PyObject *_wrap_RegionIterator_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
7428 PyObject *resultobj;
7429 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7430 wxRect result;
7431 PyObject * obj0 = 0 ;
7432 char *kwnames[] = {
7433 (char *) "self", NULL
7434 };
7435
7436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetRect",kwnames,&obj0)) goto fail;
7437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7438 if (SWIG_arg_fail(1)) SWIG_fail;
7439 {
7440 PyThreadState* __tstate = wxPyBeginAllowThreads();
7441 result = (arg1)->GetRect();
7442
7443 wxPyEndAllowThreads(__tstate);
7444 if (PyErr_Occurred()) SWIG_fail;
7445 }
7446 {
7447 wxRect * resultptr;
7448 resultptr = new wxRect((wxRect &)(result));
7449 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
7450 }
7451 return resultobj;
7452 fail:
7453 return NULL;
7454 }
7455
7456
7457 static PyObject *_wrap_RegionIterator_HaveRects(PyObject *, PyObject *args, PyObject *kwargs) {
7458 PyObject *resultobj;
7459 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7460 bool result;
7461 PyObject * obj0 = 0 ;
7462 char *kwnames[] = {
7463 (char *) "self", NULL
7464 };
7465
7466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_HaveRects",kwnames,&obj0)) goto fail;
7467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7468 if (SWIG_arg_fail(1)) SWIG_fail;
7469 {
7470 PyThreadState* __tstate = wxPyBeginAllowThreads();
7471 result = (bool)(arg1)->HaveRects();
7472
7473 wxPyEndAllowThreads(__tstate);
7474 if (PyErr_Occurred()) SWIG_fail;
7475 }
7476 {
7477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7478 }
7479 return resultobj;
7480 fail:
7481 return NULL;
7482 }
7483
7484
7485 static PyObject *_wrap_RegionIterator_Reset(PyObject *, PyObject *args, PyObject *kwargs) {
7486 PyObject *resultobj;
7487 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7488 PyObject * obj0 = 0 ;
7489 char *kwnames[] = {
7490 (char *) "self", NULL
7491 };
7492
7493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Reset",kwnames,&obj0)) goto fail;
7494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7495 if (SWIG_arg_fail(1)) SWIG_fail;
7496 {
7497 PyThreadState* __tstate = wxPyBeginAllowThreads();
7498 (arg1)->Reset();
7499
7500 wxPyEndAllowThreads(__tstate);
7501 if (PyErr_Occurred()) SWIG_fail;
7502 }
7503 Py_INCREF(Py_None); resultobj = Py_None;
7504 return resultobj;
7505 fail:
7506 return NULL;
7507 }
7508
7509
7510 static PyObject *_wrap_RegionIterator_Next(PyObject *, PyObject *args, PyObject *kwargs) {
7511 PyObject *resultobj;
7512 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7513 PyObject * obj0 = 0 ;
7514 char *kwnames[] = {
7515 (char *) "self", NULL
7516 };
7517
7518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Next",kwnames,&obj0)) goto fail;
7519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7520 if (SWIG_arg_fail(1)) SWIG_fail;
7521 {
7522 PyThreadState* __tstate = wxPyBeginAllowThreads();
7523 wxRegionIterator_Next(arg1);
7524
7525 wxPyEndAllowThreads(__tstate);
7526 if (PyErr_Occurred()) SWIG_fail;
7527 }
7528 Py_INCREF(Py_None); resultobj = Py_None;
7529 return resultobj;
7530 fail:
7531 return NULL;
7532 }
7533
7534
7535 static PyObject *_wrap_RegionIterator___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
7536 PyObject *resultobj;
7537 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7538 bool result;
7539 PyObject * obj0 = 0 ;
7540 char *kwnames[] = {
7541 (char *) "self", NULL
7542 };
7543
7544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator___nonzero__",kwnames,&obj0)) goto fail;
7545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7546 if (SWIG_arg_fail(1)) SWIG_fail;
7547 {
7548 PyThreadState* __tstate = wxPyBeginAllowThreads();
7549 result = (bool)wxRegionIterator___nonzero__(arg1);
7550
7551 wxPyEndAllowThreads(__tstate);
7552 if (PyErr_Occurred()) SWIG_fail;
7553 }
7554 {
7555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7556 }
7557 return resultobj;
7558 fail:
7559 return NULL;
7560 }
7561
7562
7563 static PyObject * RegionIterator_swigregister(PyObject *, PyObject *args) {
7564 PyObject *obj;
7565 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7566 SWIG_TypeClientData(SWIGTYPE_p_wxRegionIterator, obj);
7567 Py_INCREF(obj);
7568 return Py_BuildValue((char *)"");
7569 }
7570 static PyObject *_wrap_new_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7571 PyObject *resultobj;
7572 wxNativeFontInfo *result;
7573 char *kwnames[] = {
7574 NULL
7575 };
7576
7577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeFontInfo",kwnames)) goto fail;
7578 {
7579 PyThreadState* __tstate = wxPyBeginAllowThreads();
7580 result = (wxNativeFontInfo *)new wxNativeFontInfo();
7581
7582 wxPyEndAllowThreads(__tstate);
7583 if (PyErr_Occurred()) SWIG_fail;
7584 }
7585 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 1);
7586 return resultobj;
7587 fail:
7588 return NULL;
7589 }
7590
7591
7592 static PyObject *_wrap_delete_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7593 PyObject *resultobj;
7594 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7595 PyObject * obj0 = 0 ;
7596 char *kwnames[] = {
7597 (char *) "self", NULL
7598 };
7599
7600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeFontInfo",kwnames,&obj0)) goto fail;
7601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7602 if (SWIG_arg_fail(1)) SWIG_fail;
7603 {
7604 PyThreadState* __tstate = wxPyBeginAllowThreads();
7605 delete arg1;
7606
7607 wxPyEndAllowThreads(__tstate);
7608 if (PyErr_Occurred()) SWIG_fail;
7609 }
7610 Py_INCREF(Py_None); resultobj = Py_None;
7611 return resultobj;
7612 fail:
7613 return NULL;
7614 }
7615
7616
7617 static PyObject *_wrap_NativeFontInfo_Init(PyObject *, PyObject *args, PyObject *kwargs) {
7618 PyObject *resultobj;
7619 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7620 PyObject * obj0 = 0 ;
7621 char *kwnames[] = {
7622 (char *) "self", NULL
7623 };
7624
7625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_Init",kwnames,&obj0)) goto fail;
7626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7627 if (SWIG_arg_fail(1)) SWIG_fail;
7628 {
7629 PyThreadState* __tstate = wxPyBeginAllowThreads();
7630 (arg1)->Init();
7631
7632 wxPyEndAllowThreads(__tstate);
7633 if (PyErr_Occurred()) SWIG_fail;
7634 }
7635 Py_INCREF(Py_None); resultobj = Py_None;
7636 return resultobj;
7637 fail:
7638 return NULL;
7639 }
7640
7641
7642 static PyObject *_wrap_NativeFontInfo_InitFromFont(PyObject *, PyObject *args, PyObject *kwargs) {
7643 PyObject *resultobj;
7644 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7645 wxFont *arg2 = 0 ;
7646 PyObject * obj0 = 0 ;
7647 PyObject * obj1 = 0 ;
7648 char *kwnames[] = {
7649 (char *) "self",(char *) "font", NULL
7650 };
7651
7652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_InitFromFont",kwnames,&obj0,&obj1)) goto fail;
7653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7654 if (SWIG_arg_fail(1)) SWIG_fail;
7655 {
7656 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
7657 if (SWIG_arg_fail(2)) SWIG_fail;
7658 if (arg2 == NULL) {
7659 SWIG_null_ref("wxFont");
7660 }
7661 if (SWIG_arg_fail(2)) SWIG_fail;
7662 }
7663 {
7664 PyThreadState* __tstate = wxPyBeginAllowThreads();
7665 (arg1)->InitFromFont((wxFont const &)*arg2);
7666
7667 wxPyEndAllowThreads(__tstate);
7668 if (PyErr_Occurred()) SWIG_fail;
7669 }
7670 Py_INCREF(Py_None); resultobj = Py_None;
7671 return resultobj;
7672 fail:
7673 return NULL;
7674 }
7675
7676
7677 static PyObject *_wrap_NativeFontInfo_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
7678 PyObject *resultobj;
7679 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7680 int result;
7681 PyObject * obj0 = 0 ;
7682 char *kwnames[] = {
7683 (char *) "self", NULL
7684 };
7685
7686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetPointSize",kwnames,&obj0)) goto fail;
7687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7688 if (SWIG_arg_fail(1)) SWIG_fail;
7689 {
7690 PyThreadState* __tstate = wxPyBeginAllowThreads();
7691 result = (int)((wxNativeFontInfo const *)arg1)->GetPointSize();
7692
7693 wxPyEndAllowThreads(__tstate);
7694 if (PyErr_Occurred()) SWIG_fail;
7695 }
7696 {
7697 resultobj = SWIG_From_int((int)(result));
7698 }
7699 return resultobj;
7700 fail:
7701 return NULL;
7702 }
7703
7704
7705 static PyObject *_wrap_NativeFontInfo_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
7706 PyObject *resultobj;
7707 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7708 wxFontStyle result;
7709 PyObject * obj0 = 0 ;
7710 char *kwnames[] = {
7711 (char *) "self", NULL
7712 };
7713
7714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetStyle",kwnames,&obj0)) goto fail;
7715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7716 if (SWIG_arg_fail(1)) SWIG_fail;
7717 {
7718 PyThreadState* __tstate = wxPyBeginAllowThreads();
7719 result = (wxFontStyle)((wxNativeFontInfo const *)arg1)->GetStyle();
7720
7721 wxPyEndAllowThreads(__tstate);
7722 if (PyErr_Occurred()) SWIG_fail;
7723 }
7724 resultobj = SWIG_From_int((result));
7725 return resultobj;
7726 fail:
7727 return NULL;
7728 }
7729
7730
7731 static PyObject *_wrap_NativeFontInfo_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
7732 PyObject *resultobj;
7733 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7734 wxFontWeight result;
7735 PyObject * obj0 = 0 ;
7736 char *kwnames[] = {
7737 (char *) "self", NULL
7738 };
7739
7740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetWeight",kwnames,&obj0)) goto fail;
7741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7742 if (SWIG_arg_fail(1)) SWIG_fail;
7743 {
7744 PyThreadState* __tstate = wxPyBeginAllowThreads();
7745 result = (wxFontWeight)((wxNativeFontInfo const *)arg1)->GetWeight();
7746
7747 wxPyEndAllowThreads(__tstate);
7748 if (PyErr_Occurred()) SWIG_fail;
7749 }
7750 resultobj = SWIG_From_int((result));
7751 return resultobj;
7752 fail:
7753 return NULL;
7754 }
7755
7756
7757 static PyObject *_wrap_NativeFontInfo_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
7758 PyObject *resultobj;
7759 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7760 bool result;
7761 PyObject * obj0 = 0 ;
7762 char *kwnames[] = {
7763 (char *) "self", NULL
7764 };
7765
7766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetUnderlined",kwnames,&obj0)) goto fail;
7767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7768 if (SWIG_arg_fail(1)) SWIG_fail;
7769 {
7770 PyThreadState* __tstate = wxPyBeginAllowThreads();
7771 result = (bool)((wxNativeFontInfo const *)arg1)->GetUnderlined();
7772
7773 wxPyEndAllowThreads(__tstate);
7774 if (PyErr_Occurred()) SWIG_fail;
7775 }
7776 {
7777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7778 }
7779 return resultobj;
7780 fail:
7781 return NULL;
7782 }
7783
7784
7785 static PyObject *_wrap_NativeFontInfo_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
7786 PyObject *resultobj;
7787 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7788 wxString result;
7789 PyObject * obj0 = 0 ;
7790 char *kwnames[] = {
7791 (char *) "self", NULL
7792 };
7793
7794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFaceName",kwnames,&obj0)) goto fail;
7795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7796 if (SWIG_arg_fail(1)) SWIG_fail;
7797 {
7798 PyThreadState* __tstate = wxPyBeginAllowThreads();
7799 result = ((wxNativeFontInfo const *)arg1)->GetFaceName();
7800
7801 wxPyEndAllowThreads(__tstate);
7802 if (PyErr_Occurred()) SWIG_fail;
7803 }
7804 {
7805 #if wxUSE_UNICODE
7806 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7807 #else
7808 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7809 #endif
7810 }
7811 return resultobj;
7812 fail:
7813 return NULL;
7814 }
7815
7816
7817 static PyObject *_wrap_NativeFontInfo_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
7818 PyObject *resultobj;
7819 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7820 wxFontFamily result;
7821 PyObject * obj0 = 0 ;
7822 char *kwnames[] = {
7823 (char *) "self", NULL
7824 };
7825
7826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFamily",kwnames,&obj0)) goto fail;
7827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7828 if (SWIG_arg_fail(1)) SWIG_fail;
7829 {
7830 PyThreadState* __tstate = wxPyBeginAllowThreads();
7831 result = (wxFontFamily)((wxNativeFontInfo const *)arg1)->GetFamily();
7832
7833 wxPyEndAllowThreads(__tstate);
7834 if (PyErr_Occurred()) SWIG_fail;
7835 }
7836 resultobj = SWIG_From_int((result));
7837 return resultobj;
7838 fail:
7839 return NULL;
7840 }
7841
7842
7843 static PyObject *_wrap_NativeFontInfo_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
7844 PyObject *resultobj;
7845 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7846 wxFontEncoding result;
7847 PyObject * obj0 = 0 ;
7848 char *kwnames[] = {
7849 (char *) "self", NULL
7850 };
7851
7852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetEncoding",kwnames,&obj0)) goto fail;
7853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7854 if (SWIG_arg_fail(1)) SWIG_fail;
7855 {
7856 PyThreadState* __tstate = wxPyBeginAllowThreads();
7857 result = (wxFontEncoding)((wxNativeFontInfo const *)arg1)->GetEncoding();
7858
7859 wxPyEndAllowThreads(__tstate);
7860 if (PyErr_Occurred()) SWIG_fail;
7861 }
7862 resultobj = SWIG_From_int((result));
7863 return resultobj;
7864 fail:
7865 return NULL;
7866 }
7867
7868
7869 static PyObject *_wrap_NativeFontInfo_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
7870 PyObject *resultobj;
7871 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7872 int arg2 ;
7873 PyObject * obj0 = 0 ;
7874 PyObject * obj1 = 0 ;
7875 char *kwnames[] = {
7876 (char *) "self",(char *) "pointsize", NULL
7877 };
7878
7879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
7880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7881 if (SWIG_arg_fail(1)) SWIG_fail;
7882 {
7883 arg2 = (int)(SWIG_As_int(obj1));
7884 if (SWIG_arg_fail(2)) SWIG_fail;
7885 }
7886 {
7887 PyThreadState* __tstate = wxPyBeginAllowThreads();
7888 (arg1)->SetPointSize(arg2);
7889
7890 wxPyEndAllowThreads(__tstate);
7891 if (PyErr_Occurred()) SWIG_fail;
7892 }
7893 Py_INCREF(Py_None); resultobj = Py_None;
7894 return resultobj;
7895 fail:
7896 return NULL;
7897 }
7898
7899
7900 static PyObject *_wrap_NativeFontInfo_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
7901 PyObject *resultobj;
7902 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7903 wxFontStyle arg2 ;
7904 PyObject * obj0 = 0 ;
7905 PyObject * obj1 = 0 ;
7906 char *kwnames[] = {
7907 (char *) "self",(char *) "style", NULL
7908 };
7909
7910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetStyle",kwnames,&obj0,&obj1)) goto fail;
7911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7912 if (SWIG_arg_fail(1)) SWIG_fail;
7913 {
7914 arg2 = (wxFontStyle)(SWIG_As_int(obj1));
7915 if (SWIG_arg_fail(2)) SWIG_fail;
7916 }
7917 {
7918 PyThreadState* __tstate = wxPyBeginAllowThreads();
7919 (arg1)->SetStyle((wxFontStyle )arg2);
7920
7921 wxPyEndAllowThreads(__tstate);
7922 if (PyErr_Occurred()) SWIG_fail;
7923 }
7924 Py_INCREF(Py_None); resultobj = Py_None;
7925 return resultobj;
7926 fail:
7927 return NULL;
7928 }
7929
7930
7931 static PyObject *_wrap_NativeFontInfo_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
7932 PyObject *resultobj;
7933 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7934 wxFontWeight arg2 ;
7935 PyObject * obj0 = 0 ;
7936 PyObject * obj1 = 0 ;
7937 char *kwnames[] = {
7938 (char *) "self",(char *) "weight", NULL
7939 };
7940
7941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetWeight",kwnames,&obj0,&obj1)) goto fail;
7942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7943 if (SWIG_arg_fail(1)) SWIG_fail;
7944 {
7945 arg2 = (wxFontWeight)(SWIG_As_int(obj1));
7946 if (SWIG_arg_fail(2)) SWIG_fail;
7947 }
7948 {
7949 PyThreadState* __tstate = wxPyBeginAllowThreads();
7950 (arg1)->SetWeight((wxFontWeight )arg2);
7951
7952 wxPyEndAllowThreads(__tstate);
7953 if (PyErr_Occurred()) SWIG_fail;
7954 }
7955 Py_INCREF(Py_None); resultobj = Py_None;
7956 return resultobj;
7957 fail:
7958 return NULL;
7959 }
7960
7961
7962 static PyObject *_wrap_NativeFontInfo_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
7963 PyObject *resultobj;
7964 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7965 bool arg2 ;
7966 PyObject * obj0 = 0 ;
7967 PyObject * obj1 = 0 ;
7968 char *kwnames[] = {
7969 (char *) "self",(char *) "underlined", NULL
7970 };
7971
7972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
7973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7974 if (SWIG_arg_fail(1)) SWIG_fail;
7975 {
7976 arg2 = (bool)(SWIG_As_bool(obj1));
7977 if (SWIG_arg_fail(2)) SWIG_fail;
7978 }
7979 {
7980 PyThreadState* __tstate = wxPyBeginAllowThreads();
7981 (arg1)->SetUnderlined(arg2);
7982
7983 wxPyEndAllowThreads(__tstate);
7984 if (PyErr_Occurred()) SWIG_fail;
7985 }
7986 Py_INCREF(Py_None); resultobj = Py_None;
7987 return resultobj;
7988 fail:
7989 return NULL;
7990 }
7991
7992
7993 static PyObject *_wrap_NativeFontInfo_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
7994 PyObject *resultobj;
7995 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7996 wxString arg2 ;
7997 PyObject * obj0 = 0 ;
7998 PyObject * obj1 = 0 ;
7999 char *kwnames[] = {
8000 (char *) "self",(char *) "facename", NULL
8001 };
8002
8003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
8004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8005 if (SWIG_arg_fail(1)) SWIG_fail;
8006 {
8007 wxString* sptr = wxString_in_helper(obj1);
8008 if (sptr == NULL) SWIG_fail;
8009 arg2 = *sptr;
8010 delete sptr;
8011 }
8012 {
8013 PyThreadState* __tstate = wxPyBeginAllowThreads();
8014 (arg1)->SetFaceName(arg2);
8015
8016 wxPyEndAllowThreads(__tstate);
8017 if (PyErr_Occurred()) SWIG_fail;
8018 }
8019 Py_INCREF(Py_None); resultobj = Py_None;
8020 return resultobj;
8021 fail:
8022 return NULL;
8023 }
8024
8025
8026 static PyObject *_wrap_NativeFontInfo_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
8027 PyObject *resultobj;
8028 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8029 wxFontFamily arg2 ;
8030 PyObject * obj0 = 0 ;
8031 PyObject * obj1 = 0 ;
8032 char *kwnames[] = {
8033 (char *) "self",(char *) "family", NULL
8034 };
8035
8036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFamily",kwnames,&obj0,&obj1)) goto fail;
8037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8038 if (SWIG_arg_fail(1)) SWIG_fail;
8039 {
8040 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
8041 if (SWIG_arg_fail(2)) SWIG_fail;
8042 }
8043 {
8044 PyThreadState* __tstate = wxPyBeginAllowThreads();
8045 (arg1)->SetFamily((wxFontFamily )arg2);
8046
8047 wxPyEndAllowThreads(__tstate);
8048 if (PyErr_Occurred()) SWIG_fail;
8049 }
8050 Py_INCREF(Py_None); resultobj = Py_None;
8051 return resultobj;
8052 fail:
8053 return NULL;
8054 }
8055
8056
8057 static PyObject *_wrap_NativeFontInfo_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8058 PyObject *resultobj;
8059 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8060 wxFontEncoding arg2 ;
8061 PyObject * obj0 = 0 ;
8062 PyObject * obj1 = 0 ;
8063 char *kwnames[] = {
8064 (char *) "self",(char *) "encoding", NULL
8065 };
8066
8067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
8068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8069 if (SWIG_arg_fail(1)) SWIG_fail;
8070 {
8071 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8072 if (SWIG_arg_fail(2)) SWIG_fail;
8073 }
8074 {
8075 PyThreadState* __tstate = wxPyBeginAllowThreads();
8076 (arg1)->SetEncoding((wxFontEncoding )arg2);
8077
8078 wxPyEndAllowThreads(__tstate);
8079 if (PyErr_Occurred()) SWIG_fail;
8080 }
8081 Py_INCREF(Py_None); resultobj = Py_None;
8082 return resultobj;
8083 fail:
8084 return NULL;
8085 }
8086
8087
8088 static PyObject *_wrap_NativeFontInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8089 PyObject *resultobj;
8090 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8091 wxString *arg2 = 0 ;
8092 bool result;
8093 bool temp2 = false ;
8094 PyObject * obj0 = 0 ;
8095 PyObject * obj1 = 0 ;
8096 char *kwnames[] = {
8097 (char *) "self",(char *) "s", NULL
8098 };
8099
8100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8102 if (SWIG_arg_fail(1)) SWIG_fail;
8103 {
8104 arg2 = wxString_in_helper(obj1);
8105 if (arg2 == NULL) SWIG_fail;
8106 temp2 = true;
8107 }
8108 {
8109 PyThreadState* __tstate = wxPyBeginAllowThreads();
8110 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8111
8112 wxPyEndAllowThreads(__tstate);
8113 if (PyErr_Occurred()) SWIG_fail;
8114 }
8115 {
8116 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8117 }
8118 {
8119 if (temp2)
8120 delete arg2;
8121 }
8122 return resultobj;
8123 fail:
8124 {
8125 if (temp2)
8126 delete arg2;
8127 }
8128 return NULL;
8129 }
8130
8131
8132 static PyObject *_wrap_NativeFontInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8133 PyObject *resultobj;
8134 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8135 wxString result;
8136 PyObject * obj0 = 0 ;
8137 char *kwnames[] = {
8138 (char *) "self", NULL
8139 };
8140
8141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToString",kwnames,&obj0)) goto fail;
8142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8143 if (SWIG_arg_fail(1)) SWIG_fail;
8144 {
8145 PyThreadState* __tstate = wxPyBeginAllowThreads();
8146 result = ((wxNativeFontInfo const *)arg1)->ToString();
8147
8148 wxPyEndAllowThreads(__tstate);
8149 if (PyErr_Occurred()) SWIG_fail;
8150 }
8151 {
8152 #if wxUSE_UNICODE
8153 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8154 #else
8155 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8156 #endif
8157 }
8158 return resultobj;
8159 fail:
8160 return NULL;
8161 }
8162
8163
8164 static PyObject *_wrap_NativeFontInfo___str__(PyObject *, PyObject *args, PyObject *kwargs) {
8165 PyObject *resultobj;
8166 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8167 wxString result;
8168 PyObject * obj0 = 0 ;
8169 char *kwnames[] = {
8170 (char *) "self", NULL
8171 };
8172
8173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo___str__",kwnames,&obj0)) goto fail;
8174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8175 if (SWIG_arg_fail(1)) SWIG_fail;
8176 {
8177 PyThreadState* __tstate = wxPyBeginAllowThreads();
8178 result = wxNativeFontInfo___str__(arg1);
8179
8180 wxPyEndAllowThreads(__tstate);
8181 if (PyErr_Occurred()) SWIG_fail;
8182 }
8183 {
8184 #if wxUSE_UNICODE
8185 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8186 #else
8187 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8188 #endif
8189 }
8190 return resultobj;
8191 fail:
8192 return NULL;
8193 }
8194
8195
8196 static PyObject *_wrap_NativeFontInfo_FromUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8197 PyObject *resultobj;
8198 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8199 wxString *arg2 = 0 ;
8200 bool result;
8201 bool temp2 = false ;
8202 PyObject * obj0 = 0 ;
8203 PyObject * obj1 = 0 ;
8204 char *kwnames[] = {
8205 (char *) "self",(char *) "s", NULL
8206 };
8207
8208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromUserString",kwnames,&obj0,&obj1)) goto fail;
8209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8210 if (SWIG_arg_fail(1)) SWIG_fail;
8211 {
8212 arg2 = wxString_in_helper(obj1);
8213 if (arg2 == NULL) SWIG_fail;
8214 temp2 = true;
8215 }
8216 {
8217 PyThreadState* __tstate = wxPyBeginAllowThreads();
8218 result = (bool)(arg1)->FromUserString((wxString const &)*arg2);
8219
8220 wxPyEndAllowThreads(__tstate);
8221 if (PyErr_Occurred()) SWIG_fail;
8222 }
8223 {
8224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8225 }
8226 {
8227 if (temp2)
8228 delete arg2;
8229 }
8230 return resultobj;
8231 fail:
8232 {
8233 if (temp2)
8234 delete arg2;
8235 }
8236 return NULL;
8237 }
8238
8239
8240 static PyObject *_wrap_NativeFontInfo_ToUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8241 PyObject *resultobj;
8242 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8243 wxString result;
8244 PyObject * obj0 = 0 ;
8245 char *kwnames[] = {
8246 (char *) "self", NULL
8247 };
8248
8249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToUserString",kwnames,&obj0)) goto fail;
8250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8251 if (SWIG_arg_fail(1)) SWIG_fail;
8252 {
8253 PyThreadState* __tstate = wxPyBeginAllowThreads();
8254 result = ((wxNativeFontInfo const *)arg1)->ToUserString();
8255
8256 wxPyEndAllowThreads(__tstate);
8257 if (PyErr_Occurred()) SWIG_fail;
8258 }
8259 {
8260 #if wxUSE_UNICODE
8261 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8262 #else
8263 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8264 #endif
8265 }
8266 return resultobj;
8267 fail:
8268 return NULL;
8269 }
8270
8271
8272 static PyObject * NativeFontInfo_swigregister(PyObject *, PyObject *args) {
8273 PyObject *obj;
8274 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8275 SWIG_TypeClientData(SWIGTYPE_p_wxNativeFontInfo, obj);
8276 Py_INCREF(obj);
8277 return Py_BuildValue((char *)"");
8278 }
8279 static PyObject *_wrap_NativeEncodingInfo_facename_set(PyObject *, PyObject *args, PyObject *kwargs) {
8280 PyObject *resultobj;
8281 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8282 wxString *arg2 = (wxString *) 0 ;
8283 bool temp2 = false ;
8284 PyObject * obj0 = 0 ;
8285 PyObject * obj1 = 0 ;
8286 char *kwnames[] = {
8287 (char *) "self",(char *) "facename", NULL
8288 };
8289
8290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_facename_set",kwnames,&obj0,&obj1)) goto fail;
8291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8292 if (SWIG_arg_fail(1)) SWIG_fail;
8293 {
8294 arg2 = wxString_in_helper(obj1);
8295 if (arg2 == NULL) SWIG_fail;
8296 temp2 = true;
8297 }
8298 if (arg1) (arg1)->facename = *arg2;
8299
8300 Py_INCREF(Py_None); resultobj = Py_None;
8301 {
8302 if (temp2)
8303 delete arg2;
8304 }
8305 return resultobj;
8306 fail:
8307 {
8308 if (temp2)
8309 delete arg2;
8310 }
8311 return NULL;
8312 }
8313
8314
8315 static PyObject *_wrap_NativeEncodingInfo_facename_get(PyObject *, PyObject *args, PyObject *kwargs) {
8316 PyObject *resultobj;
8317 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8318 wxString *result;
8319 PyObject * obj0 = 0 ;
8320 char *kwnames[] = {
8321 (char *) "self", NULL
8322 };
8323
8324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_facename_get",kwnames,&obj0)) goto fail;
8325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8326 if (SWIG_arg_fail(1)) SWIG_fail;
8327 result = (wxString *)& ((arg1)->facename);
8328
8329 {
8330 #if wxUSE_UNICODE
8331 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8332 #else
8333 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8334 #endif
8335 }
8336 return resultobj;
8337 fail:
8338 return NULL;
8339 }
8340
8341
8342 static PyObject *_wrap_NativeEncodingInfo_encoding_set(PyObject *, PyObject *args, PyObject *kwargs) {
8343 PyObject *resultobj;
8344 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8345 wxFontEncoding arg2 ;
8346 PyObject * obj0 = 0 ;
8347 PyObject * obj1 = 0 ;
8348 char *kwnames[] = {
8349 (char *) "self",(char *) "encoding", NULL
8350 };
8351
8352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_encoding_set",kwnames,&obj0,&obj1)) goto fail;
8353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8354 if (SWIG_arg_fail(1)) SWIG_fail;
8355 {
8356 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8357 if (SWIG_arg_fail(2)) SWIG_fail;
8358 }
8359 if (arg1) (arg1)->encoding = (wxFontEncoding )arg2;
8360
8361 Py_INCREF(Py_None); resultobj = Py_None;
8362 return resultobj;
8363 fail:
8364 return NULL;
8365 }
8366
8367
8368 static PyObject *_wrap_NativeEncodingInfo_encoding_get(PyObject *, PyObject *args, PyObject *kwargs) {
8369 PyObject *resultobj;
8370 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8371 wxFontEncoding result;
8372 PyObject * obj0 = 0 ;
8373 char *kwnames[] = {
8374 (char *) "self", NULL
8375 };
8376
8377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_encoding_get",kwnames,&obj0)) goto fail;
8378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8379 if (SWIG_arg_fail(1)) SWIG_fail;
8380 result = (wxFontEncoding) ((arg1)->encoding);
8381
8382 resultobj = SWIG_From_int((result));
8383 return resultobj;
8384 fail:
8385 return NULL;
8386 }
8387
8388
8389 static PyObject *_wrap_new_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8390 PyObject *resultobj;
8391 wxNativeEncodingInfo *result;
8392 char *kwnames[] = {
8393 NULL
8394 };
8395
8396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeEncodingInfo",kwnames)) goto fail;
8397 {
8398 PyThreadState* __tstate = wxPyBeginAllowThreads();
8399 result = (wxNativeEncodingInfo *)new wxNativeEncodingInfo();
8400
8401 wxPyEndAllowThreads(__tstate);
8402 if (PyErr_Occurred()) SWIG_fail;
8403 }
8404 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 1);
8405 return resultobj;
8406 fail:
8407 return NULL;
8408 }
8409
8410
8411 static PyObject *_wrap_delete_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8412 PyObject *resultobj;
8413 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8414 PyObject * obj0 = 0 ;
8415 char *kwnames[] = {
8416 (char *) "self", NULL
8417 };
8418
8419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeEncodingInfo",kwnames,&obj0)) goto fail;
8420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8421 if (SWIG_arg_fail(1)) SWIG_fail;
8422 {
8423 PyThreadState* __tstate = wxPyBeginAllowThreads();
8424 delete arg1;
8425
8426 wxPyEndAllowThreads(__tstate);
8427 if (PyErr_Occurred()) SWIG_fail;
8428 }
8429 Py_INCREF(Py_None); resultobj = Py_None;
8430 return resultobj;
8431 fail:
8432 return NULL;
8433 }
8434
8435
8436 static PyObject *_wrap_NativeEncodingInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8437 PyObject *resultobj;
8438 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8439 wxString *arg2 = 0 ;
8440 bool result;
8441 bool temp2 = false ;
8442 PyObject * obj0 = 0 ;
8443 PyObject * obj1 = 0 ;
8444 char *kwnames[] = {
8445 (char *) "self",(char *) "s", NULL
8446 };
8447
8448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8450 if (SWIG_arg_fail(1)) SWIG_fail;
8451 {
8452 arg2 = wxString_in_helper(obj1);
8453 if (arg2 == NULL) SWIG_fail;
8454 temp2 = true;
8455 }
8456 {
8457 PyThreadState* __tstate = wxPyBeginAllowThreads();
8458 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8459
8460 wxPyEndAllowThreads(__tstate);
8461 if (PyErr_Occurred()) SWIG_fail;
8462 }
8463 {
8464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8465 }
8466 {
8467 if (temp2)
8468 delete arg2;
8469 }
8470 return resultobj;
8471 fail:
8472 {
8473 if (temp2)
8474 delete arg2;
8475 }
8476 return NULL;
8477 }
8478
8479
8480 static PyObject *_wrap_NativeEncodingInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8481 PyObject *resultobj;
8482 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8483 wxString result;
8484 PyObject * obj0 = 0 ;
8485 char *kwnames[] = {
8486 (char *) "self", NULL
8487 };
8488
8489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_ToString",kwnames,&obj0)) goto fail;
8490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8491 if (SWIG_arg_fail(1)) SWIG_fail;
8492 {
8493 PyThreadState* __tstate = wxPyBeginAllowThreads();
8494 result = ((wxNativeEncodingInfo const *)arg1)->ToString();
8495
8496 wxPyEndAllowThreads(__tstate);
8497 if (PyErr_Occurred()) SWIG_fail;
8498 }
8499 {
8500 #if wxUSE_UNICODE
8501 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8502 #else
8503 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8504 #endif
8505 }
8506 return resultobj;
8507 fail:
8508 return NULL;
8509 }
8510
8511
8512 static PyObject * NativeEncodingInfo_swigregister(PyObject *, PyObject *args) {
8513 PyObject *obj;
8514 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8515 SWIG_TypeClientData(SWIGTYPE_p_wxNativeEncodingInfo, obj);
8516 Py_INCREF(obj);
8517 return Py_BuildValue((char *)"");
8518 }
8519 static PyObject *_wrap_GetNativeFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8520 PyObject *resultobj;
8521 wxFontEncoding arg1 ;
8522 wxNativeEncodingInfo *result;
8523 PyObject * obj0 = 0 ;
8524 char *kwnames[] = {
8525 (char *) "encoding", NULL
8526 };
8527
8528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetNativeFontEncoding",kwnames,&obj0)) goto fail;
8529 {
8530 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8531 if (SWIG_arg_fail(1)) SWIG_fail;
8532 }
8533 {
8534 PyThreadState* __tstate = wxPyBeginAllowThreads();
8535 result = (wxNativeEncodingInfo *)wxGetNativeFontEncoding((wxFontEncoding )arg1);
8536
8537 wxPyEndAllowThreads(__tstate);
8538 if (PyErr_Occurred()) SWIG_fail;
8539 }
8540 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 0);
8541 return resultobj;
8542 fail:
8543 return NULL;
8544 }
8545
8546
8547 static PyObject *_wrap_TestFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8548 PyObject *resultobj;
8549 wxNativeEncodingInfo *arg1 = 0 ;
8550 bool result;
8551 PyObject * obj0 = 0 ;
8552 char *kwnames[] = {
8553 (char *) "info", NULL
8554 };
8555
8556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TestFontEncoding",kwnames,&obj0)) goto fail;
8557 {
8558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8559 if (SWIG_arg_fail(1)) SWIG_fail;
8560 if (arg1 == NULL) {
8561 SWIG_null_ref("wxNativeEncodingInfo");
8562 }
8563 if (SWIG_arg_fail(1)) SWIG_fail;
8564 }
8565 {
8566 PyThreadState* __tstate = wxPyBeginAllowThreads();
8567 result = (bool)wxTestFontEncoding((wxNativeEncodingInfo const &)*arg1);
8568
8569 wxPyEndAllowThreads(__tstate);
8570 if (PyErr_Occurred()) SWIG_fail;
8571 }
8572 {
8573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8574 }
8575 return resultobj;
8576 fail:
8577 return NULL;
8578 }
8579
8580
8581 static PyObject *_wrap_new_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
8582 PyObject *resultobj;
8583 wxFontMapper *result;
8584 char *kwnames[] = {
8585 NULL
8586 };
8587
8588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontMapper",kwnames)) goto fail;
8589 {
8590 PyThreadState* __tstate = wxPyBeginAllowThreads();
8591 result = (wxFontMapper *)new wxFontMapper();
8592
8593 wxPyEndAllowThreads(__tstate);
8594 if (PyErr_Occurred()) SWIG_fail;
8595 }
8596 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 1);
8597 return resultobj;
8598 fail:
8599 return NULL;
8600 }
8601
8602
8603 static PyObject *_wrap_delete_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
8604 PyObject *resultobj;
8605 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8606 PyObject * obj0 = 0 ;
8607 char *kwnames[] = {
8608 (char *) "self", NULL
8609 };
8610
8611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontMapper",kwnames,&obj0)) goto fail;
8612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8613 if (SWIG_arg_fail(1)) SWIG_fail;
8614 {
8615 PyThreadState* __tstate = wxPyBeginAllowThreads();
8616 delete arg1;
8617
8618 wxPyEndAllowThreads(__tstate);
8619 if (PyErr_Occurred()) SWIG_fail;
8620 }
8621 Py_INCREF(Py_None); resultobj = Py_None;
8622 return resultobj;
8623 fail:
8624 return NULL;
8625 }
8626
8627
8628 static PyObject *_wrap_FontMapper_Get(PyObject *, PyObject *args, PyObject *kwargs) {
8629 PyObject *resultobj;
8630 wxFontMapper *result;
8631 char *kwnames[] = {
8632 NULL
8633 };
8634
8635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_Get",kwnames)) goto fail;
8636 {
8637 PyThreadState* __tstate = wxPyBeginAllowThreads();
8638 result = (wxFontMapper *)wxFontMapper::Get();
8639
8640 wxPyEndAllowThreads(__tstate);
8641 if (PyErr_Occurred()) SWIG_fail;
8642 }
8643 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
8644 return resultobj;
8645 fail:
8646 return NULL;
8647 }
8648
8649
8650 static PyObject *_wrap_FontMapper_Set(PyObject *, PyObject *args, PyObject *kwargs) {
8651 PyObject *resultobj;
8652 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8653 wxFontMapper *result;
8654 PyObject * obj0 = 0 ;
8655 char *kwnames[] = {
8656 (char *) "mapper", NULL
8657 };
8658
8659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_Set",kwnames,&obj0)) goto fail;
8660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8661 if (SWIG_arg_fail(1)) SWIG_fail;
8662 {
8663 PyThreadState* __tstate = wxPyBeginAllowThreads();
8664 result = (wxFontMapper *)wxFontMapper::Set(arg1);
8665
8666 wxPyEndAllowThreads(__tstate);
8667 if (PyErr_Occurred()) SWIG_fail;
8668 }
8669 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
8670 return resultobj;
8671 fail:
8672 return NULL;
8673 }
8674
8675
8676 static PyObject *_wrap_FontMapper_CharsetToEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8677 PyObject *resultobj;
8678 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8679 wxString *arg2 = 0 ;
8680 bool arg3 = (bool) true ;
8681 wxFontEncoding result;
8682 bool temp2 = false ;
8683 PyObject * obj0 = 0 ;
8684 PyObject * obj1 = 0 ;
8685 PyObject * obj2 = 0 ;
8686 char *kwnames[] = {
8687 (char *) "self",(char *) "charset",(char *) "interactive", NULL
8688 };
8689
8690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_CharsetToEncoding",kwnames,&obj0,&obj1,&obj2)) goto fail;
8691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8692 if (SWIG_arg_fail(1)) SWIG_fail;
8693 {
8694 arg2 = wxString_in_helper(obj1);
8695 if (arg2 == NULL) SWIG_fail;
8696 temp2 = true;
8697 }
8698 if (obj2) {
8699 {
8700 arg3 = (bool)(SWIG_As_bool(obj2));
8701 if (SWIG_arg_fail(3)) SWIG_fail;
8702 }
8703 }
8704 {
8705 PyThreadState* __tstate = wxPyBeginAllowThreads();
8706 result = (wxFontEncoding)(arg1)->CharsetToEncoding((wxString const &)*arg2,arg3);
8707
8708 wxPyEndAllowThreads(__tstate);
8709 if (PyErr_Occurred()) SWIG_fail;
8710 }
8711 resultobj = SWIG_From_int((result));
8712 {
8713 if (temp2)
8714 delete arg2;
8715 }
8716 return resultobj;
8717 fail:
8718 {
8719 if (temp2)
8720 delete arg2;
8721 }
8722 return NULL;
8723 }
8724
8725
8726 static PyObject *_wrap_FontMapper_GetSupportedEncodingsCount(PyObject *, PyObject *args, PyObject *kwargs) {
8727 PyObject *resultobj;
8728 size_t result;
8729 char *kwnames[] = {
8730 NULL
8731 };
8732
8733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetSupportedEncodingsCount",kwnames)) goto fail;
8734 {
8735 PyThreadState* __tstate = wxPyBeginAllowThreads();
8736 result = (size_t)wxFontMapper::GetSupportedEncodingsCount();
8737
8738 wxPyEndAllowThreads(__tstate);
8739 if (PyErr_Occurred()) SWIG_fail;
8740 }
8741 {
8742 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
8743 }
8744 return resultobj;
8745 fail:
8746 return NULL;
8747 }
8748
8749
8750 static PyObject *_wrap_FontMapper_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8751 PyObject *resultobj;
8752 size_t arg1 ;
8753 wxFontEncoding result;
8754 PyObject * obj0 = 0 ;
8755 char *kwnames[] = {
8756 (char *) "n", NULL
8757 };
8758
8759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncoding",kwnames,&obj0)) goto fail;
8760 {
8761 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8762 if (SWIG_arg_fail(1)) SWIG_fail;
8763 }
8764 {
8765 PyThreadState* __tstate = wxPyBeginAllowThreads();
8766 result = (wxFontEncoding)wxFontMapper::GetEncoding(arg1);
8767
8768 wxPyEndAllowThreads(__tstate);
8769 if (PyErr_Occurred()) SWIG_fail;
8770 }
8771 resultobj = SWIG_From_int((result));
8772 return resultobj;
8773 fail:
8774 return NULL;
8775 }
8776
8777
8778 static PyObject *_wrap_FontMapper_GetEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
8779 PyObject *resultobj;
8780 wxFontEncoding arg1 ;
8781 wxString result;
8782 PyObject * obj0 = 0 ;
8783 char *kwnames[] = {
8784 (char *) "encoding", NULL
8785 };
8786
8787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingName",kwnames,&obj0)) goto fail;
8788 {
8789 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8790 if (SWIG_arg_fail(1)) SWIG_fail;
8791 }
8792 {
8793 PyThreadState* __tstate = wxPyBeginAllowThreads();
8794 result = wxFontMapper::GetEncodingName((wxFontEncoding )arg1);
8795
8796 wxPyEndAllowThreads(__tstate);
8797 if (PyErr_Occurred()) SWIG_fail;
8798 }
8799 {
8800 #if wxUSE_UNICODE
8801 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8802 #else
8803 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8804 #endif
8805 }
8806 return resultobj;
8807 fail:
8808 return NULL;
8809 }
8810
8811
8812 static PyObject *_wrap_FontMapper_GetEncodingDescription(PyObject *, PyObject *args, PyObject *kwargs) {
8813 PyObject *resultobj;
8814 wxFontEncoding arg1 ;
8815 wxString result;
8816 PyObject * obj0 = 0 ;
8817 char *kwnames[] = {
8818 (char *) "encoding", NULL
8819 };
8820
8821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingDescription",kwnames,&obj0)) goto fail;
8822 {
8823 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8824 if (SWIG_arg_fail(1)) SWIG_fail;
8825 }
8826 {
8827 PyThreadState* __tstate = wxPyBeginAllowThreads();
8828 result = wxFontMapper::GetEncodingDescription((wxFontEncoding )arg1);
8829
8830 wxPyEndAllowThreads(__tstate);
8831 if (PyErr_Occurred()) SWIG_fail;
8832 }
8833 {
8834 #if wxUSE_UNICODE
8835 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8836 #else
8837 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8838 #endif
8839 }
8840 return resultobj;
8841 fail:
8842 return NULL;
8843 }
8844
8845
8846 static PyObject *_wrap_FontMapper_GetEncodingFromName(PyObject *, PyObject *args, PyObject *kwargs) {
8847 PyObject *resultobj;
8848 wxString *arg1 = 0 ;
8849 wxFontEncoding result;
8850 bool temp1 = false ;
8851 PyObject * obj0 = 0 ;
8852 char *kwnames[] = {
8853 (char *) "name", NULL
8854 };
8855
8856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingFromName",kwnames,&obj0)) goto fail;
8857 {
8858 arg1 = wxString_in_helper(obj0);
8859 if (arg1 == NULL) SWIG_fail;
8860 temp1 = true;
8861 }
8862 {
8863 PyThreadState* __tstate = wxPyBeginAllowThreads();
8864 result = (wxFontEncoding)wxFontMapper::GetEncodingFromName((wxString const &)*arg1);
8865
8866 wxPyEndAllowThreads(__tstate);
8867 if (PyErr_Occurred()) SWIG_fail;
8868 }
8869 resultobj = SWIG_From_int((result));
8870 {
8871 if (temp1)
8872 delete arg1;
8873 }
8874 return resultobj;
8875 fail:
8876 {
8877 if (temp1)
8878 delete arg1;
8879 }
8880 return NULL;
8881 }
8882
8883
8884 static PyObject *_wrap_FontMapper_SetConfig(PyObject *, PyObject *args, PyObject *kwargs) {
8885 PyObject *resultobj;
8886 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8887 wxConfigBase *arg2 = (wxConfigBase *) 0 ;
8888 PyObject * obj0 = 0 ;
8889 PyObject * obj1 = 0 ;
8890 char *kwnames[] = {
8891 (char *) "self",(char *) "config", NULL
8892 };
8893
8894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfig",kwnames,&obj0,&obj1)) goto fail;
8895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8896 if (SWIG_arg_fail(1)) SWIG_fail;
8897 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
8898 if (SWIG_arg_fail(2)) SWIG_fail;
8899 {
8900 PyThreadState* __tstate = wxPyBeginAllowThreads();
8901 (arg1)->SetConfig(arg2);
8902
8903 wxPyEndAllowThreads(__tstate);
8904 if (PyErr_Occurred()) SWIG_fail;
8905 }
8906 Py_INCREF(Py_None); resultobj = Py_None;
8907 return resultobj;
8908 fail:
8909 return NULL;
8910 }
8911
8912
8913 static PyObject *_wrap_FontMapper_SetConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
8914 PyObject *resultobj;
8915 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8916 wxString *arg2 = 0 ;
8917 bool temp2 = false ;
8918 PyObject * obj0 = 0 ;
8919 PyObject * obj1 = 0 ;
8920 char *kwnames[] = {
8921 (char *) "self",(char *) "prefix", NULL
8922 };
8923
8924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfigPath",kwnames,&obj0,&obj1)) goto fail;
8925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8926 if (SWIG_arg_fail(1)) SWIG_fail;
8927 {
8928 arg2 = wxString_in_helper(obj1);
8929 if (arg2 == NULL) SWIG_fail;
8930 temp2 = true;
8931 }
8932 {
8933 PyThreadState* __tstate = wxPyBeginAllowThreads();
8934 (arg1)->SetConfigPath((wxString const &)*arg2);
8935
8936 wxPyEndAllowThreads(__tstate);
8937 if (PyErr_Occurred()) SWIG_fail;
8938 }
8939 Py_INCREF(Py_None); resultobj = Py_None;
8940 {
8941 if (temp2)
8942 delete arg2;
8943 }
8944 return resultobj;
8945 fail:
8946 {
8947 if (temp2)
8948 delete arg2;
8949 }
8950 return NULL;
8951 }
8952
8953
8954 static PyObject *_wrap_FontMapper_GetDefaultConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
8955 PyObject *resultobj;
8956 wxString result;
8957 char *kwnames[] = {
8958 NULL
8959 };
8960
8961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetDefaultConfigPath",kwnames)) goto fail;
8962 {
8963 PyThreadState* __tstate = wxPyBeginAllowThreads();
8964 result = wxFontMapper::GetDefaultConfigPath();
8965
8966 wxPyEndAllowThreads(__tstate);
8967 if (PyErr_Occurred()) SWIG_fail;
8968 }
8969 {
8970 #if wxUSE_UNICODE
8971 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8972 #else
8973 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8974 #endif
8975 }
8976 return resultobj;
8977 fail:
8978 return NULL;
8979 }
8980
8981
8982 static PyObject *_wrap_FontMapper_GetAltForEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8983 PyObject *resultobj;
8984 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8985 wxFontEncoding arg2 ;
8986 wxString const &arg3_defvalue = wxPyEmptyString ;
8987 wxString *arg3 = (wxString *) &arg3_defvalue ;
8988 bool arg4 = (bool) true ;
8989 PyObject *result;
8990 bool temp3 = false ;
8991 PyObject * obj0 = 0 ;
8992 PyObject * obj1 = 0 ;
8993 PyObject * obj2 = 0 ;
8994 PyObject * obj3 = 0 ;
8995 char *kwnames[] = {
8996 (char *) "self",(char *) "encoding",(char *) "facename",(char *) "interactive", NULL
8997 };
8998
8999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:FontMapper_GetAltForEncoding",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9001 if (SWIG_arg_fail(1)) SWIG_fail;
9002 {
9003 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9004 if (SWIG_arg_fail(2)) SWIG_fail;
9005 }
9006 if (obj2) {
9007 {
9008 arg3 = wxString_in_helper(obj2);
9009 if (arg3 == NULL) SWIG_fail;
9010 temp3 = true;
9011 }
9012 }
9013 if (obj3) {
9014 {
9015 arg4 = (bool)(SWIG_As_bool(obj3));
9016 if (SWIG_arg_fail(4)) SWIG_fail;
9017 }
9018 }
9019 {
9020 PyThreadState* __tstate = wxPyBeginAllowThreads();
9021 result = (PyObject *)wxFontMapper_GetAltForEncoding(arg1,(wxFontEncoding )arg2,(wxString const &)*arg3,arg4);
9022
9023 wxPyEndAllowThreads(__tstate);
9024 if (PyErr_Occurred()) SWIG_fail;
9025 }
9026 resultobj = result;
9027 {
9028 if (temp3)
9029 delete arg3;
9030 }
9031 return resultobj;
9032 fail:
9033 {
9034 if (temp3)
9035 delete arg3;
9036 }
9037 return NULL;
9038 }
9039
9040
9041 static PyObject *_wrap_FontMapper_IsEncodingAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
9042 PyObject *resultobj;
9043 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9044 wxFontEncoding arg2 ;
9045 wxString const &arg3_defvalue = wxPyEmptyString ;
9046 wxString *arg3 = (wxString *) &arg3_defvalue ;
9047 bool result;
9048 bool temp3 = false ;
9049 PyObject * obj0 = 0 ;
9050 PyObject * obj1 = 0 ;
9051 PyObject * obj2 = 0 ;
9052 char *kwnames[] = {
9053 (char *) "self",(char *) "encoding",(char *) "facename", NULL
9054 };
9055
9056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_IsEncodingAvailable",kwnames,&obj0,&obj1,&obj2)) goto fail;
9057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9058 if (SWIG_arg_fail(1)) SWIG_fail;
9059 {
9060 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9061 if (SWIG_arg_fail(2)) SWIG_fail;
9062 }
9063 if (obj2) {
9064 {
9065 arg3 = wxString_in_helper(obj2);
9066 if (arg3 == NULL) SWIG_fail;
9067 temp3 = true;
9068 }
9069 }
9070 {
9071 PyThreadState* __tstate = wxPyBeginAllowThreads();
9072 result = (bool)(arg1)->IsEncodingAvailable((wxFontEncoding )arg2,(wxString const &)*arg3);
9073
9074 wxPyEndAllowThreads(__tstate);
9075 if (PyErr_Occurred()) SWIG_fail;
9076 }
9077 {
9078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9079 }
9080 {
9081 if (temp3)
9082 delete arg3;
9083 }
9084 return resultobj;
9085 fail:
9086 {
9087 if (temp3)
9088 delete arg3;
9089 }
9090 return NULL;
9091 }
9092
9093
9094 static PyObject *_wrap_FontMapper_SetDialogParent(PyObject *, PyObject *args, PyObject *kwargs) {
9095 PyObject *resultobj;
9096 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9097 wxWindow *arg2 = (wxWindow *) 0 ;
9098 PyObject * obj0 = 0 ;
9099 PyObject * obj1 = 0 ;
9100 char *kwnames[] = {
9101 (char *) "self",(char *) "parent", NULL
9102 };
9103
9104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogParent",kwnames,&obj0,&obj1)) goto fail;
9105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9106 if (SWIG_arg_fail(1)) SWIG_fail;
9107 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9108 if (SWIG_arg_fail(2)) SWIG_fail;
9109 {
9110 PyThreadState* __tstate = wxPyBeginAllowThreads();
9111 (arg1)->SetDialogParent(arg2);
9112
9113 wxPyEndAllowThreads(__tstate);
9114 if (PyErr_Occurred()) SWIG_fail;
9115 }
9116 Py_INCREF(Py_None); resultobj = Py_None;
9117 return resultobj;
9118 fail:
9119 return NULL;
9120 }
9121
9122
9123 static PyObject *_wrap_FontMapper_SetDialogTitle(PyObject *, PyObject *args, PyObject *kwargs) {
9124 PyObject *resultobj;
9125 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9126 wxString *arg2 = 0 ;
9127 bool temp2 = false ;
9128 PyObject * obj0 = 0 ;
9129 PyObject * obj1 = 0 ;
9130 char *kwnames[] = {
9131 (char *) "self",(char *) "title", NULL
9132 };
9133
9134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogTitle",kwnames,&obj0,&obj1)) goto fail;
9135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9136 if (SWIG_arg_fail(1)) SWIG_fail;
9137 {
9138 arg2 = wxString_in_helper(obj1);
9139 if (arg2 == NULL) SWIG_fail;
9140 temp2 = true;
9141 }
9142 {
9143 PyThreadState* __tstate = wxPyBeginAllowThreads();
9144 (arg1)->SetDialogTitle((wxString const &)*arg2);
9145
9146 wxPyEndAllowThreads(__tstate);
9147 if (PyErr_Occurred()) SWIG_fail;
9148 }
9149 Py_INCREF(Py_None); resultobj = Py_None;
9150 {
9151 if (temp2)
9152 delete arg2;
9153 }
9154 return resultobj;
9155 fail:
9156 {
9157 if (temp2)
9158 delete arg2;
9159 }
9160 return NULL;
9161 }
9162
9163
9164 static PyObject * FontMapper_swigregister(PyObject *, PyObject *args) {
9165 PyObject *obj;
9166 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9167 SWIG_TypeClientData(SWIGTYPE_p_wxFontMapper, obj);
9168 Py_INCREF(obj);
9169 return Py_BuildValue((char *)"");
9170 }
9171 static PyObject *_wrap_new_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9172 PyObject *resultobj;
9173 int arg1 ;
9174 int arg2 ;
9175 int arg3 ;
9176 int arg4 ;
9177 bool arg5 = (bool) false ;
9178 wxString const &arg6_defvalue = wxPyEmptyString ;
9179 wxString *arg6 = (wxString *) &arg6_defvalue ;
9180 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9181 wxFont *result;
9182 bool temp6 = false ;
9183 PyObject * obj0 = 0 ;
9184 PyObject * obj1 = 0 ;
9185 PyObject * obj2 = 0 ;
9186 PyObject * obj3 = 0 ;
9187 PyObject * obj4 = 0 ;
9188 PyObject * obj5 = 0 ;
9189 PyObject * obj6 = 0 ;
9190 char *kwnames[] = {
9191 (char *) "pointSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "face",(char *) "encoding", NULL
9192 };
9193
9194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_Font",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9195 {
9196 arg1 = (int)(SWIG_As_int(obj0));
9197 if (SWIG_arg_fail(1)) SWIG_fail;
9198 }
9199 {
9200 arg2 = (int)(SWIG_As_int(obj1));
9201 if (SWIG_arg_fail(2)) SWIG_fail;
9202 }
9203 {
9204 arg3 = (int)(SWIG_As_int(obj2));
9205 if (SWIG_arg_fail(3)) SWIG_fail;
9206 }
9207 {
9208 arg4 = (int)(SWIG_As_int(obj3));
9209 if (SWIG_arg_fail(4)) SWIG_fail;
9210 }
9211 if (obj4) {
9212 {
9213 arg5 = (bool)(SWIG_As_bool(obj4));
9214 if (SWIG_arg_fail(5)) SWIG_fail;
9215 }
9216 }
9217 if (obj5) {
9218 {
9219 arg6 = wxString_in_helper(obj5);
9220 if (arg6 == NULL) SWIG_fail;
9221 temp6 = true;
9222 }
9223 }
9224 if (obj6) {
9225 {
9226 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9227 if (SWIG_arg_fail(7)) SWIG_fail;
9228 }
9229 }
9230 {
9231 if (!wxPyCheckForApp()) SWIG_fail;
9232 PyThreadState* __tstate = wxPyBeginAllowThreads();
9233 result = (wxFont *)new wxFont(arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9234
9235 wxPyEndAllowThreads(__tstate);
9236 if (PyErr_Occurred()) SWIG_fail;
9237 }
9238 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9239 {
9240 if (temp6)
9241 delete arg6;
9242 }
9243 return resultobj;
9244 fail:
9245 {
9246 if (temp6)
9247 delete arg6;
9248 }
9249 return NULL;
9250 }
9251
9252
9253 static PyObject *_wrap_delete_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9254 PyObject *resultobj;
9255 wxFont *arg1 = (wxFont *) 0 ;
9256 PyObject * obj0 = 0 ;
9257 char *kwnames[] = {
9258 (char *) "self", NULL
9259 };
9260
9261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Font",kwnames,&obj0)) goto fail;
9262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9263 if (SWIG_arg_fail(1)) SWIG_fail;
9264 {
9265 PyThreadState* __tstate = wxPyBeginAllowThreads();
9266 delete arg1;
9267
9268 wxPyEndAllowThreads(__tstate);
9269 if (PyErr_Occurred()) SWIG_fail;
9270 }
9271 Py_INCREF(Py_None); resultobj = Py_None;
9272 return resultobj;
9273 fail:
9274 return NULL;
9275 }
9276
9277
9278 static PyObject *_wrap_new_FontFromNativeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9279 PyObject *resultobj;
9280 wxNativeFontInfo *arg1 = 0 ;
9281 wxFont *result;
9282 PyObject * obj0 = 0 ;
9283 char *kwnames[] = {
9284 (char *) "info", NULL
9285 };
9286
9287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfo",kwnames,&obj0)) goto fail;
9288 {
9289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
9290 if (SWIG_arg_fail(1)) SWIG_fail;
9291 if (arg1 == NULL) {
9292 SWIG_null_ref("wxNativeFontInfo");
9293 }
9294 if (SWIG_arg_fail(1)) SWIG_fail;
9295 }
9296 {
9297 if (!wxPyCheckForApp()) SWIG_fail;
9298 PyThreadState* __tstate = wxPyBeginAllowThreads();
9299 result = (wxFont *)new wxFont((wxNativeFontInfo const &)*arg1);
9300
9301 wxPyEndAllowThreads(__tstate);
9302 if (PyErr_Occurred()) SWIG_fail;
9303 }
9304 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9305 return resultobj;
9306 fail:
9307 return NULL;
9308 }
9309
9310
9311 static PyObject *_wrap_new_FontFromNativeInfoString(PyObject *, PyObject *args, PyObject *kwargs) {
9312 PyObject *resultobj;
9313 wxString *arg1 = 0 ;
9314 wxFont *result;
9315 bool temp1 = false ;
9316 PyObject * obj0 = 0 ;
9317 char *kwnames[] = {
9318 (char *) "info", NULL
9319 };
9320
9321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfoString",kwnames,&obj0)) goto fail;
9322 {
9323 arg1 = wxString_in_helper(obj0);
9324 if (arg1 == NULL) SWIG_fail;
9325 temp1 = true;
9326 }
9327 {
9328 if (!wxPyCheckForApp()) SWIG_fail;
9329 PyThreadState* __tstate = wxPyBeginAllowThreads();
9330 result = (wxFont *)new_wxFont((wxString const &)*arg1);
9331
9332 wxPyEndAllowThreads(__tstate);
9333 if (PyErr_Occurred()) SWIG_fail;
9334 }
9335 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9336 {
9337 if (temp1)
9338 delete arg1;
9339 }
9340 return resultobj;
9341 fail:
9342 {
9343 if (temp1)
9344 delete arg1;
9345 }
9346 return NULL;
9347 }
9348
9349
9350 static PyObject *_wrap_new_Font2(PyObject *, PyObject *args, PyObject *kwargs) {
9351 PyObject *resultobj;
9352 int arg1 ;
9353 wxFontFamily arg2 ;
9354 int arg3 = (int) wxFONTFLAG_DEFAULT ;
9355 wxString const &arg4_defvalue = wxPyEmptyString ;
9356 wxString *arg4 = (wxString *) &arg4_defvalue ;
9357 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9358 wxFont *result;
9359 bool temp4 = false ;
9360 PyObject * obj0 = 0 ;
9361 PyObject * obj1 = 0 ;
9362 PyObject * obj2 = 0 ;
9363 PyObject * obj3 = 0 ;
9364 PyObject * obj4 = 0 ;
9365 char *kwnames[] = {
9366 (char *) "pointSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
9367 };
9368
9369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_Font2",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
9370 {
9371 arg1 = (int)(SWIG_As_int(obj0));
9372 if (SWIG_arg_fail(1)) SWIG_fail;
9373 }
9374 {
9375 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
9376 if (SWIG_arg_fail(2)) SWIG_fail;
9377 }
9378 if (obj2) {
9379 {
9380 arg3 = (int)(SWIG_As_int(obj2));
9381 if (SWIG_arg_fail(3)) SWIG_fail;
9382 }
9383 }
9384 if (obj3) {
9385 {
9386 arg4 = wxString_in_helper(obj3);
9387 if (arg4 == NULL) SWIG_fail;
9388 temp4 = true;
9389 }
9390 }
9391 if (obj4) {
9392 {
9393 arg5 = (wxFontEncoding)(SWIG_As_int(obj4));
9394 if (SWIG_arg_fail(5)) SWIG_fail;
9395 }
9396 }
9397 {
9398 if (!wxPyCheckForApp()) SWIG_fail;
9399 PyThreadState* __tstate = wxPyBeginAllowThreads();
9400 result = (wxFont *)new_wxFont(arg1,(wxFontFamily )arg2,arg3,(wxString const &)*arg4,(wxFontEncoding )arg5);
9401
9402 wxPyEndAllowThreads(__tstate);
9403 if (PyErr_Occurred()) SWIG_fail;
9404 }
9405 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9406 {
9407 if (temp4)
9408 delete arg4;
9409 }
9410 return resultobj;
9411 fail:
9412 {
9413 if (temp4)
9414 delete arg4;
9415 }
9416 return NULL;
9417 }
9418
9419
9420 static PyObject *_wrap_new_FontFromPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9421 PyObject *resultobj;
9422 wxSize *arg1 = 0 ;
9423 int arg2 ;
9424 int arg3 ;
9425 int arg4 ;
9426 bool arg5 = (bool) false ;
9427 wxString const &arg6_defvalue = wxEmptyString ;
9428 wxString *arg6 = (wxString *) &arg6_defvalue ;
9429 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9430 wxFont *result;
9431 wxSize temp1 ;
9432 bool temp6 = false ;
9433 PyObject * obj0 = 0 ;
9434 PyObject * obj1 = 0 ;
9435 PyObject * obj2 = 0 ;
9436 PyObject * obj3 = 0 ;
9437 PyObject * obj4 = 0 ;
9438 PyObject * obj5 = 0 ;
9439 PyObject * obj6 = 0 ;
9440 char *kwnames[] = {
9441 (char *) "pixelSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underlined",(char *) "face",(char *) "encoding", NULL
9442 };
9443
9444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_FontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9445 {
9446 arg1 = &temp1;
9447 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
9448 }
9449 {
9450 arg2 = (int)(SWIG_As_int(obj1));
9451 if (SWIG_arg_fail(2)) SWIG_fail;
9452 }
9453 {
9454 arg3 = (int)(SWIG_As_int(obj2));
9455 if (SWIG_arg_fail(3)) SWIG_fail;
9456 }
9457 {
9458 arg4 = (int)(SWIG_As_int(obj3));
9459 if (SWIG_arg_fail(4)) SWIG_fail;
9460 }
9461 if (obj4) {
9462 {
9463 arg5 = (bool)(SWIG_As_bool(obj4));
9464 if (SWIG_arg_fail(5)) SWIG_fail;
9465 }
9466 }
9467 if (obj5) {
9468 {
9469 arg6 = wxString_in_helper(obj5);
9470 if (arg6 == NULL) SWIG_fail;
9471 temp6 = true;
9472 }
9473 }
9474 if (obj6) {
9475 {
9476 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9477 if (SWIG_arg_fail(7)) SWIG_fail;
9478 }
9479 }
9480 {
9481 if (!wxPyCheckForApp()) SWIG_fail;
9482 PyThreadState* __tstate = wxPyBeginAllowThreads();
9483 result = (wxFont *)new_wxFont((wxSize const &)*arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9484
9485 wxPyEndAllowThreads(__tstate);
9486 if (PyErr_Occurred()) SWIG_fail;
9487 }
9488 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9489 {
9490 if (temp6)
9491 delete arg6;
9492 }
9493 return resultobj;
9494 fail:
9495 {
9496 if (temp6)
9497 delete arg6;
9498 }
9499 return NULL;
9500 }
9501
9502
9503 static PyObject *_wrap_Font_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
9504 PyObject *resultobj;
9505 wxFont *arg1 = (wxFont *) 0 ;
9506 bool result;
9507 PyObject * obj0 = 0 ;
9508 char *kwnames[] = {
9509 (char *) "self", NULL
9510 };
9511
9512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_Ok",kwnames,&obj0)) goto fail;
9513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9514 if (SWIG_arg_fail(1)) SWIG_fail;
9515 {
9516 PyThreadState* __tstate = wxPyBeginAllowThreads();
9517 result = (bool)((wxFont const *)arg1)->Ok();
9518
9519 wxPyEndAllowThreads(__tstate);
9520 if (PyErr_Occurred()) SWIG_fail;
9521 }
9522 {
9523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9524 }
9525 return resultobj;
9526 fail:
9527 return NULL;
9528 }
9529
9530
9531 static PyObject *_wrap_Font___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
9532 PyObject *resultobj;
9533 wxFont *arg1 = (wxFont *) 0 ;
9534 wxFont *arg2 = (wxFont *) 0 ;
9535 bool result;
9536 PyObject * obj0 = 0 ;
9537 PyObject * obj1 = 0 ;
9538 char *kwnames[] = {
9539 (char *) "self",(char *) "other", NULL
9540 };
9541
9542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___eq__",kwnames,&obj0,&obj1)) goto fail;
9543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9544 if (SWIG_arg_fail(1)) SWIG_fail;
9545 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9546 if (SWIG_arg_fail(2)) SWIG_fail;
9547 {
9548 PyThreadState* __tstate = wxPyBeginAllowThreads();
9549 result = (bool)wxFont___eq__(arg1,(wxFont const *)arg2);
9550
9551 wxPyEndAllowThreads(__tstate);
9552 if (PyErr_Occurred()) SWIG_fail;
9553 }
9554 {
9555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9556 }
9557 return resultobj;
9558 fail:
9559 return NULL;
9560 }
9561
9562
9563 static PyObject *_wrap_Font___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
9564 PyObject *resultobj;
9565 wxFont *arg1 = (wxFont *) 0 ;
9566 wxFont *arg2 = (wxFont *) 0 ;
9567 bool result;
9568 PyObject * obj0 = 0 ;
9569 PyObject * obj1 = 0 ;
9570 char *kwnames[] = {
9571 (char *) "self",(char *) "other", NULL
9572 };
9573
9574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___ne__",kwnames,&obj0,&obj1)) goto fail;
9575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9576 if (SWIG_arg_fail(1)) SWIG_fail;
9577 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9578 if (SWIG_arg_fail(2)) SWIG_fail;
9579 {
9580 PyThreadState* __tstate = wxPyBeginAllowThreads();
9581 result = (bool)wxFont___ne__(arg1,(wxFont const *)arg2);
9582
9583 wxPyEndAllowThreads(__tstate);
9584 if (PyErr_Occurred()) SWIG_fail;
9585 }
9586 {
9587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9588 }
9589 return resultobj;
9590 fail:
9591 return NULL;
9592 }
9593
9594
9595 static PyObject *_wrap_Font_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
9596 PyObject *resultobj;
9597 wxFont *arg1 = (wxFont *) 0 ;
9598 int result;
9599 PyObject * obj0 = 0 ;
9600 char *kwnames[] = {
9601 (char *) "self", NULL
9602 };
9603
9604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPointSize",kwnames,&obj0)) goto fail;
9605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9606 if (SWIG_arg_fail(1)) SWIG_fail;
9607 {
9608 PyThreadState* __tstate = wxPyBeginAllowThreads();
9609 result = (int)((wxFont const *)arg1)->GetPointSize();
9610
9611 wxPyEndAllowThreads(__tstate);
9612 if (PyErr_Occurred()) SWIG_fail;
9613 }
9614 {
9615 resultobj = SWIG_From_int((int)(result));
9616 }
9617 return resultobj;
9618 fail:
9619 return NULL;
9620 }
9621
9622
9623 static PyObject *_wrap_Font_GetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9624 PyObject *resultobj;
9625 wxFont *arg1 = (wxFont *) 0 ;
9626 wxSize result;
9627 PyObject * obj0 = 0 ;
9628 char *kwnames[] = {
9629 (char *) "self", NULL
9630 };
9631
9632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPixelSize",kwnames,&obj0)) goto fail;
9633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9634 if (SWIG_arg_fail(1)) SWIG_fail;
9635 {
9636 PyThreadState* __tstate = wxPyBeginAllowThreads();
9637 result = ((wxFont const *)arg1)->GetPixelSize();
9638
9639 wxPyEndAllowThreads(__tstate);
9640 if (PyErr_Occurred()) SWIG_fail;
9641 }
9642 {
9643 wxSize * resultptr;
9644 resultptr = new wxSize((wxSize &)(result));
9645 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
9646 }
9647 return resultobj;
9648 fail:
9649 return NULL;
9650 }
9651
9652
9653 static PyObject *_wrap_Font_IsUsingSizeInPixels(PyObject *, PyObject *args, PyObject *kwargs) {
9654 PyObject *resultobj;
9655 wxFont *arg1 = (wxFont *) 0 ;
9656 bool result;
9657 PyObject * obj0 = 0 ;
9658 char *kwnames[] = {
9659 (char *) "self", NULL
9660 };
9661
9662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsUsingSizeInPixels",kwnames,&obj0)) goto fail;
9663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9664 if (SWIG_arg_fail(1)) SWIG_fail;
9665 {
9666 PyThreadState* __tstate = wxPyBeginAllowThreads();
9667 result = (bool)((wxFont const *)arg1)->IsUsingSizeInPixels();
9668
9669 wxPyEndAllowThreads(__tstate);
9670 if (PyErr_Occurred()) SWIG_fail;
9671 }
9672 {
9673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9674 }
9675 return resultobj;
9676 fail:
9677 return NULL;
9678 }
9679
9680
9681 static PyObject *_wrap_Font_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
9682 PyObject *resultobj;
9683 wxFont *arg1 = (wxFont *) 0 ;
9684 int result;
9685 PyObject * obj0 = 0 ;
9686 char *kwnames[] = {
9687 (char *) "self", NULL
9688 };
9689
9690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamily",kwnames,&obj0)) goto fail;
9691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9692 if (SWIG_arg_fail(1)) SWIG_fail;
9693 {
9694 PyThreadState* __tstate = wxPyBeginAllowThreads();
9695 result = (int)((wxFont const *)arg1)->GetFamily();
9696
9697 wxPyEndAllowThreads(__tstate);
9698 if (PyErr_Occurred()) SWIG_fail;
9699 }
9700 {
9701 resultobj = SWIG_From_int((int)(result));
9702 }
9703 return resultobj;
9704 fail:
9705 return NULL;
9706 }
9707
9708
9709 static PyObject *_wrap_Font_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
9710 PyObject *resultobj;
9711 wxFont *arg1 = (wxFont *) 0 ;
9712 int result;
9713 PyObject * obj0 = 0 ;
9714 char *kwnames[] = {
9715 (char *) "self", NULL
9716 };
9717
9718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyle",kwnames,&obj0)) goto fail;
9719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9720 if (SWIG_arg_fail(1)) SWIG_fail;
9721 {
9722 PyThreadState* __tstate = wxPyBeginAllowThreads();
9723 result = (int)((wxFont const *)arg1)->GetStyle();
9724
9725 wxPyEndAllowThreads(__tstate);
9726 if (PyErr_Occurred()) SWIG_fail;
9727 }
9728 {
9729 resultobj = SWIG_From_int((int)(result));
9730 }
9731 return resultobj;
9732 fail:
9733 return NULL;
9734 }
9735
9736
9737 static PyObject *_wrap_Font_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
9738 PyObject *resultobj;
9739 wxFont *arg1 = (wxFont *) 0 ;
9740 int result;
9741 PyObject * obj0 = 0 ;
9742 char *kwnames[] = {
9743 (char *) "self", NULL
9744 };
9745
9746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeight",kwnames,&obj0)) goto fail;
9747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9748 if (SWIG_arg_fail(1)) SWIG_fail;
9749 {
9750 PyThreadState* __tstate = wxPyBeginAllowThreads();
9751 result = (int)((wxFont const *)arg1)->GetWeight();
9752
9753 wxPyEndAllowThreads(__tstate);
9754 if (PyErr_Occurred()) SWIG_fail;
9755 }
9756 {
9757 resultobj = SWIG_From_int((int)(result));
9758 }
9759 return resultobj;
9760 fail:
9761 return NULL;
9762 }
9763
9764
9765 static PyObject *_wrap_Font_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
9766 PyObject *resultobj;
9767 wxFont *arg1 = (wxFont *) 0 ;
9768 bool result;
9769 PyObject * obj0 = 0 ;
9770 char *kwnames[] = {
9771 (char *) "self", NULL
9772 };
9773
9774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetUnderlined",kwnames,&obj0)) goto fail;
9775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9776 if (SWIG_arg_fail(1)) SWIG_fail;
9777 {
9778 PyThreadState* __tstate = wxPyBeginAllowThreads();
9779 result = (bool)((wxFont const *)arg1)->GetUnderlined();
9780
9781 wxPyEndAllowThreads(__tstate);
9782 if (PyErr_Occurred()) SWIG_fail;
9783 }
9784 {
9785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9786 }
9787 return resultobj;
9788 fail:
9789 return NULL;
9790 }
9791
9792
9793 static PyObject *_wrap_Font_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
9794 PyObject *resultobj;
9795 wxFont *arg1 = (wxFont *) 0 ;
9796 wxString result;
9797 PyObject * obj0 = 0 ;
9798 char *kwnames[] = {
9799 (char *) "self", NULL
9800 };
9801
9802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFaceName",kwnames,&obj0)) goto fail;
9803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9804 if (SWIG_arg_fail(1)) SWIG_fail;
9805 {
9806 PyThreadState* __tstate = wxPyBeginAllowThreads();
9807 result = ((wxFont const *)arg1)->GetFaceName();
9808
9809 wxPyEndAllowThreads(__tstate);
9810 if (PyErr_Occurred()) SWIG_fail;
9811 }
9812 {
9813 #if wxUSE_UNICODE
9814 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9815 #else
9816 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9817 #endif
9818 }
9819 return resultobj;
9820 fail:
9821 return NULL;
9822 }
9823
9824
9825 static PyObject *_wrap_Font_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9826 PyObject *resultobj;
9827 wxFont *arg1 = (wxFont *) 0 ;
9828 wxFontEncoding result;
9829 PyObject * obj0 = 0 ;
9830 char *kwnames[] = {
9831 (char *) "self", NULL
9832 };
9833
9834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetEncoding",kwnames,&obj0)) goto fail;
9835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9836 if (SWIG_arg_fail(1)) SWIG_fail;
9837 {
9838 PyThreadState* __tstate = wxPyBeginAllowThreads();
9839 result = (wxFontEncoding)((wxFont const *)arg1)->GetEncoding();
9840
9841 wxPyEndAllowThreads(__tstate);
9842 if (PyErr_Occurred()) SWIG_fail;
9843 }
9844 resultobj = SWIG_From_int((result));
9845 return resultobj;
9846 fail:
9847 return NULL;
9848 }
9849
9850
9851 static PyObject *_wrap_Font_GetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9852 PyObject *resultobj;
9853 wxFont *arg1 = (wxFont *) 0 ;
9854 wxNativeFontInfo *result;
9855 PyObject * obj0 = 0 ;
9856 char *kwnames[] = {
9857 (char *) "self", NULL
9858 };
9859
9860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfo",kwnames,&obj0)) goto fail;
9861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9862 if (SWIG_arg_fail(1)) SWIG_fail;
9863 {
9864 PyThreadState* __tstate = wxPyBeginAllowThreads();
9865 result = (wxNativeFontInfo *)((wxFont const *)arg1)->GetNativeFontInfo();
9866
9867 wxPyEndAllowThreads(__tstate);
9868 if (PyErr_Occurred()) SWIG_fail;
9869 }
9870 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 0);
9871 return resultobj;
9872 fail:
9873 return NULL;
9874 }
9875
9876
9877 static PyObject *_wrap_Font_IsFixedWidth(PyObject *, PyObject *args, PyObject *kwargs) {
9878 PyObject *resultobj;
9879 wxFont *arg1 = (wxFont *) 0 ;
9880 bool result;
9881 PyObject * obj0 = 0 ;
9882 char *kwnames[] = {
9883 (char *) "self", NULL
9884 };
9885
9886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsFixedWidth",kwnames,&obj0)) goto fail;
9887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9888 if (SWIG_arg_fail(1)) SWIG_fail;
9889 {
9890 PyThreadState* __tstate = wxPyBeginAllowThreads();
9891 result = (bool)((wxFont const *)arg1)->IsFixedWidth();
9892
9893 wxPyEndAllowThreads(__tstate);
9894 if (PyErr_Occurred()) SWIG_fail;
9895 }
9896 {
9897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9898 }
9899 return resultobj;
9900 fail:
9901 return NULL;
9902 }
9903
9904
9905 static PyObject *_wrap_Font_GetNativeFontInfoDesc(PyObject *, PyObject *args, PyObject *kwargs) {
9906 PyObject *resultobj;
9907 wxFont *arg1 = (wxFont *) 0 ;
9908 wxString result;
9909 PyObject * obj0 = 0 ;
9910 char *kwnames[] = {
9911 (char *) "self", NULL
9912 };
9913
9914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoDesc",kwnames,&obj0)) goto fail;
9915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9916 if (SWIG_arg_fail(1)) SWIG_fail;
9917 {
9918 PyThreadState* __tstate = wxPyBeginAllowThreads();
9919 result = ((wxFont const *)arg1)->GetNativeFontInfoDesc();
9920
9921 wxPyEndAllowThreads(__tstate);
9922 if (PyErr_Occurred()) SWIG_fail;
9923 }
9924 {
9925 #if wxUSE_UNICODE
9926 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9927 #else
9928 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9929 #endif
9930 }
9931 return resultobj;
9932 fail:
9933 return NULL;
9934 }
9935
9936
9937 static PyObject *_wrap_Font_GetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
9938 PyObject *resultobj;
9939 wxFont *arg1 = (wxFont *) 0 ;
9940 wxString result;
9941 PyObject * obj0 = 0 ;
9942 char *kwnames[] = {
9943 (char *) "self", NULL
9944 };
9945
9946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoUserDesc",kwnames,&obj0)) goto fail;
9947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9948 if (SWIG_arg_fail(1)) SWIG_fail;
9949 {
9950 PyThreadState* __tstate = wxPyBeginAllowThreads();
9951 result = ((wxFont const *)arg1)->GetNativeFontInfoUserDesc();
9952
9953 wxPyEndAllowThreads(__tstate);
9954 if (PyErr_Occurred()) SWIG_fail;
9955 }
9956 {
9957 #if wxUSE_UNICODE
9958 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9959 #else
9960 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9961 #endif
9962 }
9963 return resultobj;
9964 fail:
9965 return NULL;
9966 }
9967
9968
9969 static PyObject *_wrap_Font_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
9970 PyObject *resultobj;
9971 wxFont *arg1 = (wxFont *) 0 ;
9972 int arg2 ;
9973 PyObject * obj0 = 0 ;
9974 PyObject * obj1 = 0 ;
9975 char *kwnames[] = {
9976 (char *) "self",(char *) "pointSize", NULL
9977 };
9978
9979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
9980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9981 if (SWIG_arg_fail(1)) SWIG_fail;
9982 {
9983 arg2 = (int)(SWIG_As_int(obj1));
9984 if (SWIG_arg_fail(2)) SWIG_fail;
9985 }
9986 {
9987 PyThreadState* __tstate = wxPyBeginAllowThreads();
9988 (arg1)->SetPointSize(arg2);
9989
9990 wxPyEndAllowThreads(__tstate);
9991 if (PyErr_Occurred()) SWIG_fail;
9992 }
9993 Py_INCREF(Py_None); resultobj = Py_None;
9994 return resultobj;
9995 fail:
9996 return NULL;
9997 }
9998
9999
10000 static PyObject *_wrap_Font_SetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10001 PyObject *resultobj;
10002 wxFont *arg1 = (wxFont *) 0 ;
10003 wxSize *arg2 = 0 ;
10004 wxSize temp2 ;
10005 PyObject * obj0 = 0 ;
10006 PyObject * obj1 = 0 ;
10007 char *kwnames[] = {
10008 (char *) "self",(char *) "pixelSize", NULL
10009 };
10010
10011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPixelSize",kwnames,&obj0,&obj1)) goto fail;
10012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10013 if (SWIG_arg_fail(1)) SWIG_fail;
10014 {
10015 arg2 = &temp2;
10016 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
10017 }
10018 {
10019 PyThreadState* __tstate = wxPyBeginAllowThreads();
10020 (arg1)->SetPixelSize((wxSize const &)*arg2);
10021
10022 wxPyEndAllowThreads(__tstate);
10023 if (PyErr_Occurred()) SWIG_fail;
10024 }
10025 Py_INCREF(Py_None); resultobj = Py_None;
10026 return resultobj;
10027 fail:
10028 return NULL;
10029 }
10030
10031
10032 static PyObject *_wrap_Font_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
10033 PyObject *resultobj;
10034 wxFont *arg1 = (wxFont *) 0 ;
10035 int arg2 ;
10036 PyObject * obj0 = 0 ;
10037 PyObject * obj1 = 0 ;
10038 char *kwnames[] = {
10039 (char *) "self",(char *) "family", NULL
10040 };
10041
10042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFamily",kwnames,&obj0,&obj1)) goto fail;
10043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10044 if (SWIG_arg_fail(1)) SWIG_fail;
10045 {
10046 arg2 = (int)(SWIG_As_int(obj1));
10047 if (SWIG_arg_fail(2)) SWIG_fail;
10048 }
10049 {
10050 PyThreadState* __tstate = wxPyBeginAllowThreads();
10051 (arg1)->SetFamily(arg2);
10052
10053 wxPyEndAllowThreads(__tstate);
10054 if (PyErr_Occurred()) SWIG_fail;
10055 }
10056 Py_INCREF(Py_None); resultobj = Py_None;
10057 return resultobj;
10058 fail:
10059 return NULL;
10060 }
10061
10062
10063 static PyObject *_wrap_Font_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10064 PyObject *resultobj;
10065 wxFont *arg1 = (wxFont *) 0 ;
10066 int arg2 ;
10067 PyObject * obj0 = 0 ;
10068 PyObject * obj1 = 0 ;
10069 char *kwnames[] = {
10070 (char *) "self",(char *) "style", NULL
10071 };
10072
10073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetStyle",kwnames,&obj0,&obj1)) goto fail;
10074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10075 if (SWIG_arg_fail(1)) SWIG_fail;
10076 {
10077 arg2 = (int)(SWIG_As_int(obj1));
10078 if (SWIG_arg_fail(2)) SWIG_fail;
10079 }
10080 {
10081 PyThreadState* __tstate = wxPyBeginAllowThreads();
10082 (arg1)->SetStyle(arg2);
10083
10084 wxPyEndAllowThreads(__tstate);
10085 if (PyErr_Occurred()) SWIG_fail;
10086 }
10087 Py_INCREF(Py_None); resultobj = Py_None;
10088 return resultobj;
10089 fail:
10090 return NULL;
10091 }
10092
10093
10094 static PyObject *_wrap_Font_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
10095 PyObject *resultobj;
10096 wxFont *arg1 = (wxFont *) 0 ;
10097 int arg2 ;
10098 PyObject * obj0 = 0 ;
10099 PyObject * obj1 = 0 ;
10100 char *kwnames[] = {
10101 (char *) "self",(char *) "weight", NULL
10102 };
10103
10104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetWeight",kwnames,&obj0,&obj1)) goto fail;
10105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10106 if (SWIG_arg_fail(1)) SWIG_fail;
10107 {
10108 arg2 = (int)(SWIG_As_int(obj1));
10109 if (SWIG_arg_fail(2)) SWIG_fail;
10110 }
10111 {
10112 PyThreadState* __tstate = wxPyBeginAllowThreads();
10113 (arg1)->SetWeight(arg2);
10114
10115 wxPyEndAllowThreads(__tstate);
10116 if (PyErr_Occurred()) SWIG_fail;
10117 }
10118 Py_INCREF(Py_None); resultobj = Py_None;
10119 return resultobj;
10120 fail:
10121 return NULL;
10122 }
10123
10124
10125 static PyObject *_wrap_Font_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
10126 PyObject *resultobj;
10127 wxFont *arg1 = (wxFont *) 0 ;
10128 wxString *arg2 = 0 ;
10129 bool temp2 = false ;
10130 PyObject * obj0 = 0 ;
10131 PyObject * obj1 = 0 ;
10132 char *kwnames[] = {
10133 (char *) "self",(char *) "faceName", NULL
10134 };
10135
10136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
10137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10138 if (SWIG_arg_fail(1)) SWIG_fail;
10139 {
10140 arg2 = wxString_in_helper(obj1);
10141 if (arg2 == NULL) SWIG_fail;
10142 temp2 = true;
10143 }
10144 {
10145 PyThreadState* __tstate = wxPyBeginAllowThreads();
10146 (arg1)->SetFaceName((wxString const &)*arg2);
10147
10148 wxPyEndAllowThreads(__tstate);
10149 if (PyErr_Occurred()) SWIG_fail;
10150 }
10151 Py_INCREF(Py_None); resultobj = Py_None;
10152 {
10153 if (temp2)
10154 delete arg2;
10155 }
10156 return resultobj;
10157 fail:
10158 {
10159 if (temp2)
10160 delete arg2;
10161 }
10162 return NULL;
10163 }
10164
10165
10166 static PyObject *_wrap_Font_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
10167 PyObject *resultobj;
10168 wxFont *arg1 = (wxFont *) 0 ;
10169 bool arg2 ;
10170 PyObject * obj0 = 0 ;
10171 PyObject * obj1 = 0 ;
10172 char *kwnames[] = {
10173 (char *) "self",(char *) "underlined", NULL
10174 };
10175
10176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
10177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10178 if (SWIG_arg_fail(1)) SWIG_fail;
10179 {
10180 arg2 = (bool)(SWIG_As_bool(obj1));
10181 if (SWIG_arg_fail(2)) SWIG_fail;
10182 }
10183 {
10184 PyThreadState* __tstate = wxPyBeginAllowThreads();
10185 (arg1)->SetUnderlined(arg2);
10186
10187 wxPyEndAllowThreads(__tstate);
10188 if (PyErr_Occurred()) SWIG_fail;
10189 }
10190 Py_INCREF(Py_None); resultobj = Py_None;
10191 return resultobj;
10192 fail:
10193 return NULL;
10194 }
10195
10196
10197 static PyObject *_wrap_Font_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10198 PyObject *resultobj;
10199 wxFont *arg1 = (wxFont *) 0 ;
10200 wxFontEncoding arg2 ;
10201 PyObject * obj0 = 0 ;
10202 PyObject * obj1 = 0 ;
10203 char *kwnames[] = {
10204 (char *) "self",(char *) "encoding", NULL
10205 };
10206
10207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
10208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10209 if (SWIG_arg_fail(1)) SWIG_fail;
10210 {
10211 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10212 if (SWIG_arg_fail(2)) SWIG_fail;
10213 }
10214 {
10215 PyThreadState* __tstate = wxPyBeginAllowThreads();
10216 (arg1)->SetEncoding((wxFontEncoding )arg2);
10217
10218 wxPyEndAllowThreads(__tstate);
10219 if (PyErr_Occurred()) SWIG_fail;
10220 }
10221 Py_INCREF(Py_None); resultobj = Py_None;
10222 return resultobj;
10223 fail:
10224 return NULL;
10225 }
10226
10227
10228 static PyObject *_wrap_Font_SetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10229 PyObject *resultobj;
10230 wxFont *arg1 = (wxFont *) 0 ;
10231 wxNativeFontInfo *arg2 = 0 ;
10232 PyObject * obj0 = 0 ;
10233 PyObject * obj1 = 0 ;
10234 char *kwnames[] = {
10235 (char *) "self",(char *) "info", NULL
10236 };
10237
10238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfo",kwnames,&obj0,&obj1)) goto fail;
10239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10240 if (SWIG_arg_fail(1)) SWIG_fail;
10241 {
10242 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
10243 if (SWIG_arg_fail(2)) SWIG_fail;
10244 if (arg2 == NULL) {
10245 SWIG_null_ref("wxNativeFontInfo");
10246 }
10247 if (SWIG_arg_fail(2)) SWIG_fail;
10248 }
10249 {
10250 PyThreadState* __tstate = wxPyBeginAllowThreads();
10251 (arg1)->SetNativeFontInfo((wxNativeFontInfo const &)*arg2);
10252
10253 wxPyEndAllowThreads(__tstate);
10254 if (PyErr_Occurred()) SWIG_fail;
10255 }
10256 Py_INCREF(Py_None); resultobj = Py_None;
10257 return resultobj;
10258 fail:
10259 return NULL;
10260 }
10261
10262
10263 static PyObject *_wrap_Font_SetNativeFontInfoFromString(PyObject *, PyObject *args, PyObject *kwargs) {
10264 PyObject *resultobj;
10265 wxFont *arg1 = (wxFont *) 0 ;
10266 wxString *arg2 = 0 ;
10267 bool temp2 = false ;
10268 PyObject * obj0 = 0 ;
10269 PyObject * obj1 = 0 ;
10270 char *kwnames[] = {
10271 (char *) "self",(char *) "info", NULL
10272 };
10273
10274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoFromString",kwnames,&obj0,&obj1)) goto fail;
10275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10276 if (SWIG_arg_fail(1)) SWIG_fail;
10277 {
10278 arg2 = wxString_in_helper(obj1);
10279 if (arg2 == NULL) SWIG_fail;
10280 temp2 = true;
10281 }
10282 {
10283 PyThreadState* __tstate = wxPyBeginAllowThreads();
10284 (arg1)->SetNativeFontInfo((wxString const &)*arg2);
10285
10286 wxPyEndAllowThreads(__tstate);
10287 if (PyErr_Occurred()) SWIG_fail;
10288 }
10289 Py_INCREF(Py_None); resultobj = Py_None;
10290 {
10291 if (temp2)
10292 delete arg2;
10293 }
10294 return resultobj;
10295 fail:
10296 {
10297 if (temp2)
10298 delete arg2;
10299 }
10300 return NULL;
10301 }
10302
10303
10304 static PyObject *_wrap_Font_SetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10305 PyObject *resultobj;
10306 wxFont *arg1 = (wxFont *) 0 ;
10307 wxString *arg2 = 0 ;
10308 bool temp2 = false ;
10309 PyObject * obj0 = 0 ;
10310 PyObject * obj1 = 0 ;
10311 char *kwnames[] = {
10312 (char *) "self",(char *) "info", NULL
10313 };
10314
10315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoUserDesc",kwnames,&obj0,&obj1)) goto fail;
10316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10317 if (SWIG_arg_fail(1)) SWIG_fail;
10318 {
10319 arg2 = wxString_in_helper(obj1);
10320 if (arg2 == NULL) SWIG_fail;
10321 temp2 = true;
10322 }
10323 {
10324 PyThreadState* __tstate = wxPyBeginAllowThreads();
10325 (arg1)->SetNativeFontInfoUserDesc((wxString const &)*arg2);
10326
10327 wxPyEndAllowThreads(__tstate);
10328 if (PyErr_Occurred()) SWIG_fail;
10329 }
10330 Py_INCREF(Py_None); resultobj = Py_None;
10331 {
10332 if (temp2)
10333 delete arg2;
10334 }
10335 return resultobj;
10336 fail:
10337 {
10338 if (temp2)
10339 delete arg2;
10340 }
10341 return NULL;
10342 }
10343
10344
10345 static PyObject *_wrap_Font_GetFamilyString(PyObject *, PyObject *args, PyObject *kwargs) {
10346 PyObject *resultobj;
10347 wxFont *arg1 = (wxFont *) 0 ;
10348 wxString result;
10349 PyObject * obj0 = 0 ;
10350 char *kwnames[] = {
10351 (char *) "self", NULL
10352 };
10353
10354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamilyString",kwnames,&obj0)) goto fail;
10355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10356 if (SWIG_arg_fail(1)) SWIG_fail;
10357 {
10358 PyThreadState* __tstate = wxPyBeginAllowThreads();
10359 result = ((wxFont const *)arg1)->GetFamilyString();
10360
10361 wxPyEndAllowThreads(__tstate);
10362 if (PyErr_Occurred()) SWIG_fail;
10363 }
10364 {
10365 #if wxUSE_UNICODE
10366 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10367 #else
10368 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10369 #endif
10370 }
10371 return resultobj;
10372 fail:
10373 return NULL;
10374 }
10375
10376
10377 static PyObject *_wrap_Font_GetStyleString(PyObject *, PyObject *args, PyObject *kwargs) {
10378 PyObject *resultobj;
10379 wxFont *arg1 = (wxFont *) 0 ;
10380 wxString result;
10381 PyObject * obj0 = 0 ;
10382 char *kwnames[] = {
10383 (char *) "self", NULL
10384 };
10385
10386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyleString",kwnames,&obj0)) goto fail;
10387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10388 if (SWIG_arg_fail(1)) SWIG_fail;
10389 {
10390 PyThreadState* __tstate = wxPyBeginAllowThreads();
10391 result = ((wxFont const *)arg1)->GetStyleString();
10392
10393 wxPyEndAllowThreads(__tstate);
10394 if (PyErr_Occurred()) SWIG_fail;
10395 }
10396 {
10397 #if wxUSE_UNICODE
10398 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10399 #else
10400 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10401 #endif
10402 }
10403 return resultobj;
10404 fail:
10405 return NULL;
10406 }
10407
10408
10409 static PyObject *_wrap_Font_GetWeightString(PyObject *, PyObject *args, PyObject *kwargs) {
10410 PyObject *resultobj;
10411 wxFont *arg1 = (wxFont *) 0 ;
10412 wxString result;
10413 PyObject * obj0 = 0 ;
10414 char *kwnames[] = {
10415 (char *) "self", NULL
10416 };
10417
10418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeightString",kwnames,&obj0)) goto fail;
10419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10420 if (SWIG_arg_fail(1)) SWIG_fail;
10421 {
10422 PyThreadState* __tstate = wxPyBeginAllowThreads();
10423 result = ((wxFont const *)arg1)->GetWeightString();
10424
10425 wxPyEndAllowThreads(__tstate);
10426 if (PyErr_Occurred()) SWIG_fail;
10427 }
10428 {
10429 #if wxUSE_UNICODE
10430 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10431 #else
10432 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10433 #endif
10434 }
10435 return resultobj;
10436 fail:
10437 return NULL;
10438 }
10439
10440
10441 static PyObject *_wrap_Font_SetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
10442 PyObject *resultobj;
10443 wxFont *arg1 = (wxFont *) 0 ;
10444 bool arg2 = (bool) true ;
10445 PyObject * obj0 = 0 ;
10446 PyObject * obj1 = 0 ;
10447 char *kwnames[] = {
10448 (char *) "self",(char *) "no", NULL
10449 };
10450
10451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Font_SetNoAntiAliasing",kwnames,&obj0,&obj1)) goto fail;
10452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10453 if (SWIG_arg_fail(1)) SWIG_fail;
10454 if (obj1) {
10455 {
10456 arg2 = (bool)(SWIG_As_bool(obj1));
10457 if (SWIG_arg_fail(2)) SWIG_fail;
10458 }
10459 }
10460 {
10461 PyThreadState* __tstate = wxPyBeginAllowThreads();
10462 (arg1)->SetNoAntiAliasing(arg2);
10463
10464 wxPyEndAllowThreads(__tstate);
10465 if (PyErr_Occurred()) SWIG_fail;
10466 }
10467 Py_INCREF(Py_None); resultobj = Py_None;
10468 return resultobj;
10469 fail:
10470 return NULL;
10471 }
10472
10473
10474 static PyObject *_wrap_Font_GetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
10475 PyObject *resultobj;
10476 wxFont *arg1 = (wxFont *) 0 ;
10477 bool result;
10478 PyObject * obj0 = 0 ;
10479 char *kwnames[] = {
10480 (char *) "self", NULL
10481 };
10482
10483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNoAntiAliasing",kwnames,&obj0)) goto fail;
10484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10485 if (SWIG_arg_fail(1)) SWIG_fail;
10486 {
10487 PyThreadState* __tstate = wxPyBeginAllowThreads();
10488 result = (bool)((wxFont const *)arg1)->GetNoAntiAliasing();
10489
10490 wxPyEndAllowThreads(__tstate);
10491 if (PyErr_Occurred()) SWIG_fail;
10492 }
10493 {
10494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10495 }
10496 return resultobj;
10497 fail:
10498 return NULL;
10499 }
10500
10501
10502 static PyObject *_wrap_Font_GetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10503 PyObject *resultobj;
10504 wxFontEncoding result;
10505 char *kwnames[] = {
10506 NULL
10507 };
10508
10509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Font_GetDefaultEncoding",kwnames)) goto fail;
10510 {
10511 if (!wxPyCheckForApp()) SWIG_fail;
10512 PyThreadState* __tstate = wxPyBeginAllowThreads();
10513 result = (wxFontEncoding)wxFont::GetDefaultEncoding();
10514
10515 wxPyEndAllowThreads(__tstate);
10516 if (PyErr_Occurred()) SWIG_fail;
10517 }
10518 resultobj = SWIG_From_int((result));
10519 return resultobj;
10520 fail:
10521 return NULL;
10522 }
10523
10524
10525 static PyObject *_wrap_Font_SetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10526 PyObject *resultobj;
10527 wxFontEncoding arg1 ;
10528 PyObject * obj0 = 0 ;
10529 char *kwnames[] = {
10530 (char *) "encoding", NULL
10531 };
10532
10533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_SetDefaultEncoding",kwnames,&obj0)) goto fail;
10534 {
10535 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
10536 if (SWIG_arg_fail(1)) SWIG_fail;
10537 }
10538 {
10539 if (!wxPyCheckForApp()) SWIG_fail;
10540 PyThreadState* __tstate = wxPyBeginAllowThreads();
10541 wxFont::SetDefaultEncoding((wxFontEncoding )arg1);
10542
10543 wxPyEndAllowThreads(__tstate);
10544 if (PyErr_Occurred()) SWIG_fail;
10545 }
10546 Py_INCREF(Py_None); resultobj = Py_None;
10547 return resultobj;
10548 fail:
10549 return NULL;
10550 }
10551
10552
10553 static PyObject * Font_swigregister(PyObject *, PyObject *args) {
10554 PyObject *obj;
10555 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10556 SWIG_TypeClientData(SWIGTYPE_p_wxFont, obj);
10557 Py_INCREF(obj);
10558 return Py_BuildValue((char *)"");
10559 }
10560 static PyObject *_wrap_new_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
10561 PyObject *resultobj;
10562 wxPyFontEnumerator *result;
10563 char *kwnames[] = {
10564 NULL
10565 };
10566
10567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontEnumerator",kwnames)) goto fail;
10568 {
10569 if (!wxPyCheckForApp()) SWIG_fail;
10570 PyThreadState* __tstate = wxPyBeginAllowThreads();
10571 result = (wxPyFontEnumerator *)new wxPyFontEnumerator();
10572
10573 wxPyEndAllowThreads(__tstate);
10574 if (PyErr_Occurred()) SWIG_fail;
10575 }
10576 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFontEnumerator, 1);
10577 return resultobj;
10578 fail:
10579 return NULL;
10580 }
10581
10582
10583 static PyObject *_wrap_delete_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
10584 PyObject *resultobj;
10585 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10586 PyObject * obj0 = 0 ;
10587 char *kwnames[] = {
10588 (char *) "self", NULL
10589 };
10590
10591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontEnumerator",kwnames,&obj0)) goto fail;
10592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10593 if (SWIG_arg_fail(1)) SWIG_fail;
10594 {
10595 PyThreadState* __tstate = wxPyBeginAllowThreads();
10596 delete arg1;
10597
10598 wxPyEndAllowThreads(__tstate);
10599 if (PyErr_Occurred()) SWIG_fail;
10600 }
10601 Py_INCREF(Py_None); resultobj = Py_None;
10602 return resultobj;
10603 fail:
10604 return NULL;
10605 }
10606
10607
10608 static PyObject *_wrap_FontEnumerator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10609 PyObject *resultobj;
10610 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10611 PyObject *arg2 = (PyObject *) 0 ;
10612 PyObject *arg3 = (PyObject *) 0 ;
10613 bool arg4 ;
10614 PyObject * obj0 = 0 ;
10615 PyObject * obj1 = 0 ;
10616 PyObject * obj2 = 0 ;
10617 PyObject * obj3 = 0 ;
10618 char *kwnames[] = {
10619 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10620 };
10621
10622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FontEnumerator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10624 if (SWIG_arg_fail(1)) SWIG_fail;
10625 arg2 = obj1;
10626 arg3 = obj2;
10627 {
10628 arg4 = (bool)(SWIG_As_bool(obj3));
10629 if (SWIG_arg_fail(4)) SWIG_fail;
10630 }
10631 {
10632 PyThreadState* __tstate = wxPyBeginAllowThreads();
10633 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10634
10635 wxPyEndAllowThreads(__tstate);
10636 if (PyErr_Occurred()) SWIG_fail;
10637 }
10638 Py_INCREF(Py_None); resultobj = Py_None;
10639 return resultobj;
10640 fail:
10641 return NULL;
10642 }
10643
10644
10645 static PyObject *_wrap_FontEnumerator_EnumerateFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
10646 PyObject *resultobj;
10647 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10648 wxFontEncoding arg2 = (wxFontEncoding) wxFONTENCODING_SYSTEM ;
10649 bool arg3 = (bool) false ;
10650 bool result;
10651 PyObject * obj0 = 0 ;
10652 PyObject * obj1 = 0 ;
10653 PyObject * obj2 = 0 ;
10654 char *kwnames[] = {
10655 (char *) "self",(char *) "encoding",(char *) "fixedWidthOnly", NULL
10656 };
10657
10658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FontEnumerator_EnumerateFacenames",kwnames,&obj0,&obj1,&obj2)) goto fail;
10659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10660 if (SWIG_arg_fail(1)) SWIG_fail;
10661 if (obj1) {
10662 {
10663 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10664 if (SWIG_arg_fail(2)) SWIG_fail;
10665 }
10666 }
10667 if (obj2) {
10668 {
10669 arg3 = (bool)(SWIG_As_bool(obj2));
10670 if (SWIG_arg_fail(3)) SWIG_fail;
10671 }
10672 }
10673 {
10674 PyThreadState* __tstate = wxPyBeginAllowThreads();
10675 result = (bool)(arg1)->EnumerateFacenames((wxFontEncoding )arg2,arg3);
10676
10677 wxPyEndAllowThreads(__tstate);
10678 if (PyErr_Occurred()) SWIG_fail;
10679 }
10680 {
10681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10682 }
10683 return resultobj;
10684 fail:
10685 return NULL;
10686 }
10687
10688
10689 static PyObject *_wrap_FontEnumerator_EnumerateEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
10690 PyObject *resultobj;
10691 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10692 wxString const &arg2_defvalue = wxPyEmptyString ;
10693 wxString *arg2 = (wxString *) &arg2_defvalue ;
10694 bool result;
10695 bool temp2 = false ;
10696 PyObject * obj0 = 0 ;
10697 PyObject * obj1 = 0 ;
10698 char *kwnames[] = {
10699 (char *) "self",(char *) "facename", NULL
10700 };
10701
10702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FontEnumerator_EnumerateEncodings",kwnames,&obj0,&obj1)) goto fail;
10703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10704 if (SWIG_arg_fail(1)) SWIG_fail;
10705 if (obj1) {
10706 {
10707 arg2 = wxString_in_helper(obj1);
10708 if (arg2 == NULL) SWIG_fail;
10709 temp2 = true;
10710 }
10711 }
10712 {
10713 PyThreadState* __tstate = wxPyBeginAllowThreads();
10714 result = (bool)(arg1)->EnumerateEncodings((wxString const &)*arg2);
10715
10716 wxPyEndAllowThreads(__tstate);
10717 if (PyErr_Occurred()) SWIG_fail;
10718 }
10719 {
10720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10721 }
10722 {
10723 if (temp2)
10724 delete arg2;
10725 }
10726 return resultobj;
10727 fail:
10728 {
10729 if (temp2)
10730 delete arg2;
10731 }
10732 return NULL;
10733 }
10734
10735
10736 static PyObject *_wrap_FontEnumerator_GetEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
10737 PyObject *resultobj;
10738 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10739 PyObject *result;
10740 PyObject * obj0 = 0 ;
10741 char *kwnames[] = {
10742 (char *) "self", NULL
10743 };
10744
10745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetEncodings",kwnames,&obj0)) goto fail;
10746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10747 if (SWIG_arg_fail(1)) SWIG_fail;
10748 {
10749 PyThreadState* __tstate = wxPyBeginAllowThreads();
10750 result = (PyObject *)wxPyFontEnumerator_GetEncodings(arg1);
10751
10752 wxPyEndAllowThreads(__tstate);
10753 if (PyErr_Occurred()) SWIG_fail;
10754 }
10755 resultobj = result;
10756 return resultobj;
10757 fail:
10758 return NULL;
10759 }
10760
10761
10762 static PyObject *_wrap_FontEnumerator_GetFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
10763 PyObject *resultobj;
10764 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10765 PyObject *result;
10766 PyObject * obj0 = 0 ;
10767 char *kwnames[] = {
10768 (char *) "self", NULL
10769 };
10770
10771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetFacenames",kwnames,&obj0)) goto fail;
10772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10773 if (SWIG_arg_fail(1)) SWIG_fail;
10774 {
10775 PyThreadState* __tstate = wxPyBeginAllowThreads();
10776 result = (PyObject *)wxPyFontEnumerator_GetFacenames(arg1);
10777
10778 wxPyEndAllowThreads(__tstate);
10779 if (PyErr_Occurred()) SWIG_fail;
10780 }
10781 resultobj = result;
10782 return resultobj;
10783 fail:
10784 return NULL;
10785 }
10786
10787
10788 static PyObject * FontEnumerator_swigregister(PyObject *, PyObject *args) {
10789 PyObject *obj;
10790 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10791 SWIG_TypeClientData(SWIGTYPE_p_wxPyFontEnumerator, obj);
10792 Py_INCREF(obj);
10793 return Py_BuildValue((char *)"");
10794 }
10795 static PyObject *_wrap_LanguageInfo_Language_set(PyObject *, PyObject *args, PyObject *kwargs) {
10796 PyObject *resultobj;
10797 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10798 int arg2 ;
10799 PyObject * obj0 = 0 ;
10800 PyObject * obj1 = 0 ;
10801 char *kwnames[] = {
10802 (char *) "self",(char *) "Language", NULL
10803 };
10804
10805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Language_set",kwnames,&obj0,&obj1)) goto fail;
10806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10807 if (SWIG_arg_fail(1)) SWIG_fail;
10808 {
10809 arg2 = (int)(SWIG_As_int(obj1));
10810 if (SWIG_arg_fail(2)) SWIG_fail;
10811 }
10812 if (arg1) (arg1)->Language = arg2;
10813
10814 Py_INCREF(Py_None); resultobj = Py_None;
10815 return resultobj;
10816 fail:
10817 return NULL;
10818 }
10819
10820
10821 static PyObject *_wrap_LanguageInfo_Language_get(PyObject *, PyObject *args, PyObject *kwargs) {
10822 PyObject *resultobj;
10823 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10824 int result;
10825 PyObject * obj0 = 0 ;
10826 char *kwnames[] = {
10827 (char *) "self", NULL
10828 };
10829
10830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Language_get",kwnames,&obj0)) goto fail;
10831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10832 if (SWIG_arg_fail(1)) SWIG_fail;
10833 result = (int) ((arg1)->Language);
10834
10835 {
10836 resultobj = SWIG_From_int((int)(result));
10837 }
10838 return resultobj;
10839 fail:
10840 return NULL;
10841 }
10842
10843
10844 static PyObject *_wrap_LanguageInfo_CanonicalName_set(PyObject *, PyObject *args, PyObject *kwargs) {
10845 PyObject *resultobj;
10846 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10847 wxString *arg2 = (wxString *) 0 ;
10848 bool temp2 = false ;
10849 PyObject * obj0 = 0 ;
10850 PyObject * obj1 = 0 ;
10851 char *kwnames[] = {
10852 (char *) "self",(char *) "CanonicalName", NULL
10853 };
10854
10855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_CanonicalName_set",kwnames,&obj0,&obj1)) goto fail;
10856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10857 if (SWIG_arg_fail(1)) SWIG_fail;
10858 {
10859 arg2 = wxString_in_helper(obj1);
10860 if (arg2 == NULL) SWIG_fail;
10861 temp2 = true;
10862 }
10863 if (arg1) (arg1)->CanonicalName = *arg2;
10864
10865 Py_INCREF(Py_None); resultobj = Py_None;
10866 {
10867 if (temp2)
10868 delete arg2;
10869 }
10870 return resultobj;
10871 fail:
10872 {
10873 if (temp2)
10874 delete arg2;
10875 }
10876 return NULL;
10877 }
10878
10879
10880 static PyObject *_wrap_LanguageInfo_CanonicalName_get(PyObject *, PyObject *args, PyObject *kwargs) {
10881 PyObject *resultobj;
10882 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10883 wxString *result;
10884 PyObject * obj0 = 0 ;
10885 char *kwnames[] = {
10886 (char *) "self", NULL
10887 };
10888
10889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_CanonicalName_get",kwnames,&obj0)) goto fail;
10890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10891 if (SWIG_arg_fail(1)) SWIG_fail;
10892 result = (wxString *)& ((arg1)->CanonicalName);
10893
10894 {
10895 #if wxUSE_UNICODE
10896 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10897 #else
10898 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10899 #endif
10900 }
10901 return resultobj;
10902 fail:
10903 return NULL;
10904 }
10905
10906
10907 static PyObject *_wrap_LanguageInfo_Description_set(PyObject *, PyObject *args, PyObject *kwargs) {
10908 PyObject *resultobj;
10909 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10910 wxString *arg2 = (wxString *) 0 ;
10911 bool temp2 = false ;
10912 PyObject * obj0 = 0 ;
10913 PyObject * obj1 = 0 ;
10914 char *kwnames[] = {
10915 (char *) "self",(char *) "Description", NULL
10916 };
10917
10918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Description_set",kwnames,&obj0,&obj1)) goto fail;
10919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10920 if (SWIG_arg_fail(1)) SWIG_fail;
10921 {
10922 arg2 = wxString_in_helper(obj1);
10923 if (arg2 == NULL) SWIG_fail;
10924 temp2 = true;
10925 }
10926 if (arg1) (arg1)->Description = *arg2;
10927
10928 Py_INCREF(Py_None); resultobj = Py_None;
10929 {
10930 if (temp2)
10931 delete arg2;
10932 }
10933 return resultobj;
10934 fail:
10935 {
10936 if (temp2)
10937 delete arg2;
10938 }
10939 return NULL;
10940 }
10941
10942
10943 static PyObject *_wrap_LanguageInfo_Description_get(PyObject *, PyObject *args, PyObject *kwargs) {
10944 PyObject *resultobj;
10945 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10946 wxString *result;
10947 PyObject * obj0 = 0 ;
10948 char *kwnames[] = {
10949 (char *) "self", NULL
10950 };
10951
10952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Description_get",kwnames,&obj0)) goto fail;
10953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10954 if (SWIG_arg_fail(1)) SWIG_fail;
10955 result = (wxString *)& ((arg1)->Description);
10956
10957 {
10958 #if wxUSE_UNICODE
10959 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10960 #else
10961 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10962 #endif
10963 }
10964 return resultobj;
10965 fail:
10966 return NULL;
10967 }
10968
10969
10970 static PyObject * LanguageInfo_swigregister(PyObject *, PyObject *args) {
10971 PyObject *obj;
10972 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10973 SWIG_TypeClientData(SWIGTYPE_p_wxLanguageInfo, obj);
10974 Py_INCREF(obj);
10975 return Py_BuildValue((char *)"");
10976 }
10977 static PyObject *_wrap_new_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
10978 PyObject *resultobj;
10979 int arg1 = (int) -1 ;
10980 int arg2 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
10981 wxLocale *result;
10982 PyObject * obj0 = 0 ;
10983 PyObject * obj1 = 0 ;
10984 char *kwnames[] = {
10985 (char *) "language",(char *) "flags", NULL
10986 };
10987
10988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Locale",kwnames,&obj0,&obj1)) goto fail;
10989 if (obj0) {
10990 {
10991 arg1 = (int)(SWIG_As_int(obj0));
10992 if (SWIG_arg_fail(1)) SWIG_fail;
10993 }
10994 }
10995 if (obj1) {
10996 {
10997 arg2 = (int)(SWIG_As_int(obj1));
10998 if (SWIG_arg_fail(2)) SWIG_fail;
10999 }
11000 }
11001 {
11002 PyThreadState* __tstate = wxPyBeginAllowThreads();
11003 result = (wxLocale *)new_wxLocale(arg1,arg2);
11004
11005 wxPyEndAllowThreads(__tstate);
11006 if (PyErr_Occurred()) SWIG_fail;
11007 }
11008 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 1);
11009 return resultobj;
11010 fail:
11011 return NULL;
11012 }
11013
11014
11015 static PyObject *_wrap_delete_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11016 PyObject *resultobj;
11017 wxLocale *arg1 = (wxLocale *) 0 ;
11018 PyObject * obj0 = 0 ;
11019 char *kwnames[] = {
11020 (char *) "self", NULL
11021 };
11022
11023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Locale",kwnames,&obj0)) goto fail;
11024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11025 if (SWIG_arg_fail(1)) SWIG_fail;
11026 {
11027 PyThreadState* __tstate = wxPyBeginAllowThreads();
11028 delete arg1;
11029
11030 wxPyEndAllowThreads(__tstate);
11031 if (PyErr_Occurred()) SWIG_fail;
11032 }
11033 Py_INCREF(Py_None); resultobj = Py_None;
11034 return resultobj;
11035 fail:
11036 return NULL;
11037 }
11038
11039
11040 static PyObject *_wrap_Locale_Init1(PyObject *, PyObject *args, PyObject *kwargs) {
11041 PyObject *resultobj;
11042 wxLocale *arg1 = (wxLocale *) 0 ;
11043 wxString *arg2 = 0 ;
11044 wxString const &arg3_defvalue = wxPyEmptyString ;
11045 wxString *arg3 = (wxString *) &arg3_defvalue ;
11046 wxString const &arg4_defvalue = wxPyEmptyString ;
11047 wxString *arg4 = (wxString *) &arg4_defvalue ;
11048 bool arg5 = (bool) true ;
11049 bool arg6 = (bool) false ;
11050 bool result;
11051 bool temp2 = false ;
11052 bool temp3 = false ;
11053 bool temp4 = false ;
11054 PyObject * obj0 = 0 ;
11055 PyObject * obj1 = 0 ;
11056 PyObject * obj2 = 0 ;
11057 PyObject * obj3 = 0 ;
11058 PyObject * obj4 = 0 ;
11059 PyObject * obj5 = 0 ;
11060 char *kwnames[] = {
11061 (char *) "self",(char *) "szName",(char *) "szShort",(char *) "szLocale",(char *) "bLoadDefault",(char *) "bConvertEncoding", NULL
11062 };
11063
11064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Locale_Init1",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11066 if (SWIG_arg_fail(1)) SWIG_fail;
11067 {
11068 arg2 = wxString_in_helper(obj1);
11069 if (arg2 == NULL) SWIG_fail;
11070 temp2 = true;
11071 }
11072 if (obj2) {
11073 {
11074 arg3 = wxString_in_helper(obj2);
11075 if (arg3 == NULL) SWIG_fail;
11076 temp3 = true;
11077 }
11078 }
11079 if (obj3) {
11080 {
11081 arg4 = wxString_in_helper(obj3);
11082 if (arg4 == NULL) SWIG_fail;
11083 temp4 = true;
11084 }
11085 }
11086 if (obj4) {
11087 {
11088 arg5 = (bool)(SWIG_As_bool(obj4));
11089 if (SWIG_arg_fail(5)) SWIG_fail;
11090 }
11091 }
11092 if (obj5) {
11093 {
11094 arg6 = (bool)(SWIG_As_bool(obj5));
11095 if (SWIG_arg_fail(6)) SWIG_fail;
11096 }
11097 }
11098 {
11099 PyThreadState* __tstate = wxPyBeginAllowThreads();
11100 result = (bool)wxLocale_Init1(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
11101
11102 wxPyEndAllowThreads(__tstate);
11103 if (PyErr_Occurred()) SWIG_fail;
11104 }
11105 {
11106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11107 }
11108 {
11109 if (temp2)
11110 delete arg2;
11111 }
11112 {
11113 if (temp3)
11114 delete arg3;
11115 }
11116 {
11117 if (temp4)
11118 delete arg4;
11119 }
11120 return resultobj;
11121 fail:
11122 {
11123 if (temp2)
11124 delete arg2;
11125 }
11126 {
11127 if (temp3)
11128 delete arg3;
11129 }
11130 {
11131 if (temp4)
11132 delete arg4;
11133 }
11134 return NULL;
11135 }
11136
11137
11138 static PyObject *_wrap_Locale_Init2(PyObject *, PyObject *args, PyObject *kwargs) {
11139 PyObject *resultobj;
11140 wxLocale *arg1 = (wxLocale *) 0 ;
11141 int arg2 = (int) wxLANGUAGE_DEFAULT ;
11142 int arg3 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11143 bool result;
11144 PyObject * obj0 = 0 ;
11145 PyObject * obj1 = 0 ;
11146 PyObject * obj2 = 0 ;
11147 char *kwnames[] = {
11148 (char *) "self",(char *) "language",(char *) "flags", NULL
11149 };
11150
11151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Locale_Init2",kwnames,&obj0,&obj1,&obj2)) goto fail;
11152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11153 if (SWIG_arg_fail(1)) SWIG_fail;
11154 if (obj1) {
11155 {
11156 arg2 = (int)(SWIG_As_int(obj1));
11157 if (SWIG_arg_fail(2)) SWIG_fail;
11158 }
11159 }
11160 if (obj2) {
11161 {
11162 arg3 = (int)(SWIG_As_int(obj2));
11163 if (SWIG_arg_fail(3)) SWIG_fail;
11164 }
11165 }
11166 {
11167 PyThreadState* __tstate = wxPyBeginAllowThreads();
11168 result = (bool)wxLocale_Init2(arg1,arg2,arg3);
11169
11170 wxPyEndAllowThreads(__tstate);
11171 if (PyErr_Occurred()) SWIG_fail;
11172 }
11173 {
11174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11175 }
11176 return resultobj;
11177 fail:
11178 return NULL;
11179 }
11180
11181
11182 static PyObject *_wrap_Locale_GetSystemLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11183 PyObject *resultobj;
11184 int result;
11185 char *kwnames[] = {
11186 NULL
11187 };
11188
11189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemLanguage",kwnames)) goto fail;
11190 {
11191 PyThreadState* __tstate = wxPyBeginAllowThreads();
11192 result = (int)wxLocale::GetSystemLanguage();
11193
11194 wxPyEndAllowThreads(__tstate);
11195 if (PyErr_Occurred()) SWIG_fail;
11196 }
11197 {
11198 resultobj = SWIG_From_int((int)(result));
11199 }
11200 return resultobj;
11201 fail:
11202 return NULL;
11203 }
11204
11205
11206 static PyObject *_wrap_Locale_GetSystemEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11207 PyObject *resultobj;
11208 wxFontEncoding result;
11209 char *kwnames[] = {
11210 NULL
11211 };
11212
11213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncoding",kwnames)) goto fail;
11214 {
11215 PyThreadState* __tstate = wxPyBeginAllowThreads();
11216 result = (wxFontEncoding)wxLocale::GetSystemEncoding();
11217
11218 wxPyEndAllowThreads(__tstate);
11219 if (PyErr_Occurred()) SWIG_fail;
11220 }
11221 resultobj = SWIG_From_int((result));
11222 return resultobj;
11223 fail:
11224 return NULL;
11225 }
11226
11227
11228 static PyObject *_wrap_Locale_GetSystemEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
11229 PyObject *resultobj;
11230 wxString result;
11231 char *kwnames[] = {
11232 NULL
11233 };
11234
11235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncodingName",kwnames)) goto fail;
11236 {
11237 PyThreadState* __tstate = wxPyBeginAllowThreads();
11238 result = wxLocale::GetSystemEncodingName();
11239
11240 wxPyEndAllowThreads(__tstate);
11241 if (PyErr_Occurred()) SWIG_fail;
11242 }
11243 {
11244 #if wxUSE_UNICODE
11245 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11246 #else
11247 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11248 #endif
11249 }
11250 return resultobj;
11251 fail:
11252 return NULL;
11253 }
11254
11255
11256 static PyObject *_wrap_Locale_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11257 PyObject *resultobj;
11258 wxLocale *arg1 = (wxLocale *) 0 ;
11259 bool result;
11260 PyObject * obj0 = 0 ;
11261 char *kwnames[] = {
11262 (char *) "self", NULL
11263 };
11264
11265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_IsOk",kwnames,&obj0)) goto fail;
11266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11267 if (SWIG_arg_fail(1)) SWIG_fail;
11268 {
11269 PyThreadState* __tstate = wxPyBeginAllowThreads();
11270 result = (bool)((wxLocale const *)arg1)->IsOk();
11271
11272 wxPyEndAllowThreads(__tstate);
11273 if (PyErr_Occurred()) SWIG_fail;
11274 }
11275 {
11276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11277 }
11278 return resultobj;
11279 fail:
11280 return NULL;
11281 }
11282
11283
11284 static PyObject *_wrap_Locale_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11285 PyObject *resultobj;
11286 wxLocale *arg1 = (wxLocale *) 0 ;
11287 wxString result;
11288 PyObject * obj0 = 0 ;
11289 char *kwnames[] = {
11290 (char *) "self", NULL
11291 };
11292
11293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLocale",kwnames,&obj0)) goto fail;
11294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11295 if (SWIG_arg_fail(1)) SWIG_fail;
11296 {
11297 PyThreadState* __tstate = wxPyBeginAllowThreads();
11298 result = ((wxLocale const *)arg1)->GetLocale();
11299
11300 wxPyEndAllowThreads(__tstate);
11301 if (PyErr_Occurred()) SWIG_fail;
11302 }
11303 {
11304 #if wxUSE_UNICODE
11305 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11306 #else
11307 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11308 #endif
11309 }
11310 return resultobj;
11311 fail:
11312 return NULL;
11313 }
11314
11315
11316 static PyObject *_wrap_Locale_GetLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11317 PyObject *resultobj;
11318 wxLocale *arg1 = (wxLocale *) 0 ;
11319 int result;
11320 PyObject * obj0 = 0 ;
11321 char *kwnames[] = {
11322 (char *) "self", NULL
11323 };
11324
11325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguage",kwnames,&obj0)) goto fail;
11326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11327 if (SWIG_arg_fail(1)) SWIG_fail;
11328 {
11329 PyThreadState* __tstate = wxPyBeginAllowThreads();
11330 result = (int)((wxLocale const *)arg1)->GetLanguage();
11331
11332 wxPyEndAllowThreads(__tstate);
11333 if (PyErr_Occurred()) SWIG_fail;
11334 }
11335 {
11336 resultobj = SWIG_From_int((int)(result));
11337 }
11338 return resultobj;
11339 fail:
11340 return NULL;
11341 }
11342
11343
11344 static PyObject *_wrap_Locale_GetSysName(PyObject *, PyObject *args, PyObject *kwargs) {
11345 PyObject *resultobj;
11346 wxLocale *arg1 = (wxLocale *) 0 ;
11347 wxString result;
11348 PyObject * obj0 = 0 ;
11349 char *kwnames[] = {
11350 (char *) "self", NULL
11351 };
11352
11353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetSysName",kwnames,&obj0)) goto fail;
11354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11355 if (SWIG_arg_fail(1)) SWIG_fail;
11356 {
11357 PyThreadState* __tstate = wxPyBeginAllowThreads();
11358 result = ((wxLocale const *)arg1)->GetSysName();
11359
11360 wxPyEndAllowThreads(__tstate);
11361 if (PyErr_Occurred()) SWIG_fail;
11362 }
11363 {
11364 #if wxUSE_UNICODE
11365 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11366 #else
11367 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11368 #endif
11369 }
11370 return resultobj;
11371 fail:
11372 return NULL;
11373 }
11374
11375
11376 static PyObject *_wrap_Locale_GetCanonicalName(PyObject *, PyObject *args, PyObject *kwargs) {
11377 PyObject *resultobj;
11378 wxLocale *arg1 = (wxLocale *) 0 ;
11379 wxString result;
11380 PyObject * obj0 = 0 ;
11381 char *kwnames[] = {
11382 (char *) "self", NULL
11383 };
11384
11385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetCanonicalName",kwnames,&obj0)) goto fail;
11386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11387 if (SWIG_arg_fail(1)) SWIG_fail;
11388 {
11389 PyThreadState* __tstate = wxPyBeginAllowThreads();
11390 result = ((wxLocale const *)arg1)->GetCanonicalName();
11391
11392 wxPyEndAllowThreads(__tstate);
11393 if (PyErr_Occurred()) SWIG_fail;
11394 }
11395 {
11396 #if wxUSE_UNICODE
11397 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11398 #else
11399 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11400 #endif
11401 }
11402 return resultobj;
11403 fail:
11404 return NULL;
11405 }
11406
11407
11408 static PyObject *_wrap_Locale_AddCatalogLookupPathPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
11409 PyObject *resultobj;
11410 wxString *arg1 = 0 ;
11411 bool temp1 = false ;
11412 PyObject * obj0 = 0 ;
11413 char *kwnames[] = {
11414 (char *) "prefix", NULL
11415 };
11416
11417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddCatalogLookupPathPrefix",kwnames,&obj0)) goto fail;
11418 {
11419 arg1 = wxString_in_helper(obj0);
11420 if (arg1 == NULL) SWIG_fail;
11421 temp1 = true;
11422 }
11423 {
11424 PyThreadState* __tstate = wxPyBeginAllowThreads();
11425 wxLocale::AddCatalogLookupPathPrefix((wxString const &)*arg1);
11426
11427 wxPyEndAllowThreads(__tstate);
11428 if (PyErr_Occurred()) SWIG_fail;
11429 }
11430 Py_INCREF(Py_None); resultobj = Py_None;
11431 {
11432 if (temp1)
11433 delete arg1;
11434 }
11435 return resultobj;
11436 fail:
11437 {
11438 if (temp1)
11439 delete arg1;
11440 }
11441 return NULL;
11442 }
11443
11444
11445 static PyObject *_wrap_Locale_AddCatalog(PyObject *, PyObject *args, PyObject *kwargs) {
11446 PyObject *resultobj;
11447 wxLocale *arg1 = (wxLocale *) 0 ;
11448 wxString *arg2 = 0 ;
11449 bool result;
11450 bool temp2 = false ;
11451 PyObject * obj0 = 0 ;
11452 PyObject * obj1 = 0 ;
11453 char *kwnames[] = {
11454 (char *) "self",(char *) "szDomain", NULL
11455 };
11456
11457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_AddCatalog",kwnames,&obj0,&obj1)) goto fail;
11458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11459 if (SWIG_arg_fail(1)) SWIG_fail;
11460 {
11461 arg2 = wxString_in_helper(obj1);
11462 if (arg2 == NULL) SWIG_fail;
11463 temp2 = true;
11464 }
11465 {
11466 PyThreadState* __tstate = wxPyBeginAllowThreads();
11467 result = (bool)(arg1)->AddCatalog((wxString const &)*arg2);
11468
11469 wxPyEndAllowThreads(__tstate);
11470 if (PyErr_Occurred()) SWIG_fail;
11471 }
11472 {
11473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11474 }
11475 {
11476 if (temp2)
11477 delete arg2;
11478 }
11479 return resultobj;
11480 fail:
11481 {
11482 if (temp2)
11483 delete arg2;
11484 }
11485 return NULL;
11486 }
11487
11488
11489 static PyObject *_wrap_Locale_IsLoaded(PyObject *, PyObject *args, PyObject *kwargs) {
11490 PyObject *resultobj;
11491 wxLocale *arg1 = (wxLocale *) 0 ;
11492 wxString *arg2 = 0 ;
11493 bool result;
11494 bool temp2 = false ;
11495 PyObject * obj0 = 0 ;
11496 PyObject * obj1 = 0 ;
11497 char *kwnames[] = {
11498 (char *) "self",(char *) "szDomain", NULL
11499 };
11500
11501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_IsLoaded",kwnames,&obj0,&obj1)) goto fail;
11502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11503 if (SWIG_arg_fail(1)) SWIG_fail;
11504 {
11505 arg2 = wxString_in_helper(obj1);
11506 if (arg2 == NULL) SWIG_fail;
11507 temp2 = true;
11508 }
11509 {
11510 PyThreadState* __tstate = wxPyBeginAllowThreads();
11511 result = (bool)((wxLocale const *)arg1)->IsLoaded((wxString const &)*arg2);
11512
11513 wxPyEndAllowThreads(__tstate);
11514 if (PyErr_Occurred()) SWIG_fail;
11515 }
11516 {
11517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11518 }
11519 {
11520 if (temp2)
11521 delete arg2;
11522 }
11523 return resultobj;
11524 fail:
11525 {
11526 if (temp2)
11527 delete arg2;
11528 }
11529 return NULL;
11530 }
11531
11532
11533 static PyObject *_wrap_Locale_GetLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11534 PyObject *resultobj;
11535 int arg1 ;
11536 wxLanguageInfo *result;
11537 PyObject * obj0 = 0 ;
11538 char *kwnames[] = {
11539 (char *) "lang", NULL
11540 };
11541
11542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageInfo",kwnames,&obj0)) goto fail;
11543 {
11544 arg1 = (int)(SWIG_As_int(obj0));
11545 if (SWIG_arg_fail(1)) SWIG_fail;
11546 }
11547 {
11548 PyThreadState* __tstate = wxPyBeginAllowThreads();
11549 result = (wxLanguageInfo *)wxLocale::GetLanguageInfo(arg1);
11550
11551 wxPyEndAllowThreads(__tstate);
11552 if (PyErr_Occurred()) SWIG_fail;
11553 }
11554 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
11555 return resultobj;
11556 fail:
11557 return NULL;
11558 }
11559
11560
11561 static PyObject *_wrap_Locale_GetLanguageName(PyObject *, PyObject *args, PyObject *kwargs) {
11562 PyObject *resultobj;
11563 int arg1 ;
11564 wxString result;
11565 PyObject * obj0 = 0 ;
11566 char *kwnames[] = {
11567 (char *) "lang", NULL
11568 };
11569
11570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageName",kwnames,&obj0)) goto fail;
11571 {
11572 arg1 = (int)(SWIG_As_int(obj0));
11573 if (SWIG_arg_fail(1)) SWIG_fail;
11574 }
11575 {
11576 PyThreadState* __tstate = wxPyBeginAllowThreads();
11577 result = wxLocale::GetLanguageName(arg1);
11578
11579 wxPyEndAllowThreads(__tstate);
11580 if (PyErr_Occurred()) SWIG_fail;
11581 }
11582 {
11583 #if wxUSE_UNICODE
11584 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11585 #else
11586 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11587 #endif
11588 }
11589 return resultobj;
11590 fail:
11591 return NULL;
11592 }
11593
11594
11595 static PyObject *_wrap_Locale_FindLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11596 PyObject *resultobj;
11597 wxString *arg1 = 0 ;
11598 wxLanguageInfo *result;
11599 bool temp1 = false ;
11600 PyObject * obj0 = 0 ;
11601 char *kwnames[] = {
11602 (char *) "locale", NULL
11603 };
11604
11605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_FindLanguageInfo",kwnames,&obj0)) goto fail;
11606 {
11607 arg1 = wxString_in_helper(obj0);
11608 if (arg1 == NULL) SWIG_fail;
11609 temp1 = true;
11610 }
11611 {
11612 PyThreadState* __tstate = wxPyBeginAllowThreads();
11613 result = (wxLanguageInfo *)wxLocale::FindLanguageInfo((wxString const &)*arg1);
11614
11615 wxPyEndAllowThreads(__tstate);
11616 if (PyErr_Occurred()) SWIG_fail;
11617 }
11618 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
11619 {
11620 if (temp1)
11621 delete arg1;
11622 }
11623 return resultobj;
11624 fail:
11625 {
11626 if (temp1)
11627 delete arg1;
11628 }
11629 return NULL;
11630 }
11631
11632
11633 static PyObject *_wrap_Locale_AddLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11634 PyObject *resultobj;
11635 wxLanguageInfo *arg1 = 0 ;
11636 PyObject * obj0 = 0 ;
11637 char *kwnames[] = {
11638 (char *) "info", NULL
11639 };
11640
11641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddLanguage",kwnames,&obj0)) goto fail;
11642 {
11643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11644 if (SWIG_arg_fail(1)) SWIG_fail;
11645 if (arg1 == NULL) {
11646 SWIG_null_ref("wxLanguageInfo");
11647 }
11648 if (SWIG_arg_fail(1)) SWIG_fail;
11649 }
11650 {
11651 PyThreadState* __tstate = wxPyBeginAllowThreads();
11652 wxLocale::AddLanguage((wxLanguageInfo const &)*arg1);
11653
11654 wxPyEndAllowThreads(__tstate);
11655 if (PyErr_Occurred()) SWIG_fail;
11656 }
11657 Py_INCREF(Py_None); resultobj = Py_None;
11658 return resultobj;
11659 fail:
11660 return NULL;
11661 }
11662
11663
11664 static PyObject *_wrap_Locale_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
11665 PyObject *resultobj;
11666 wxLocale *arg1 = (wxLocale *) 0 ;
11667 wxString *arg2 = 0 ;
11668 wxString const &arg3_defvalue = wxPyEmptyString ;
11669 wxString *arg3 = (wxString *) &arg3_defvalue ;
11670 wxString result;
11671 bool temp2 = false ;
11672 bool temp3 = false ;
11673 PyObject * obj0 = 0 ;
11674 PyObject * obj1 = 0 ;
11675 PyObject * obj2 = 0 ;
11676 char *kwnames[] = {
11677 (char *) "self",(char *) "szOrigString",(char *) "szDomain", NULL
11678 };
11679
11680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Locale_GetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
11681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11682 if (SWIG_arg_fail(1)) SWIG_fail;
11683 {
11684 arg2 = wxString_in_helper(obj1);
11685 if (arg2 == NULL) SWIG_fail;
11686 temp2 = true;
11687 }
11688 if (obj2) {
11689 {
11690 arg3 = wxString_in_helper(obj2);
11691 if (arg3 == NULL) SWIG_fail;
11692 temp3 = true;
11693 }
11694 }
11695 {
11696 PyThreadState* __tstate = wxPyBeginAllowThreads();
11697 result = ((wxLocale const *)arg1)->GetString((wxString const &)*arg2,(wxString const &)*arg3);
11698
11699 wxPyEndAllowThreads(__tstate);
11700 if (PyErr_Occurred()) SWIG_fail;
11701 }
11702 {
11703 #if wxUSE_UNICODE
11704 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11705 #else
11706 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11707 #endif
11708 }
11709 {
11710 if (temp2)
11711 delete arg2;
11712 }
11713 {
11714 if (temp3)
11715 delete arg3;
11716 }
11717 return resultobj;
11718 fail:
11719 {
11720 if (temp2)
11721 delete arg2;
11722 }
11723 {
11724 if (temp3)
11725 delete arg3;
11726 }
11727 return NULL;
11728 }
11729
11730
11731 static PyObject *_wrap_Locale_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
11732 PyObject *resultobj;
11733 wxLocale *arg1 = (wxLocale *) 0 ;
11734 wxString *result;
11735 PyObject * obj0 = 0 ;
11736 char *kwnames[] = {
11737 (char *) "self", NULL
11738 };
11739
11740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetName",kwnames,&obj0)) goto fail;
11741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11742 if (SWIG_arg_fail(1)) SWIG_fail;
11743 {
11744 PyThreadState* __tstate = wxPyBeginAllowThreads();
11745 {
11746 wxString const &_result_ref = ((wxLocale const *)arg1)->GetName();
11747 result = (wxString *) &_result_ref;
11748 }
11749
11750 wxPyEndAllowThreads(__tstate);
11751 if (PyErr_Occurred()) SWIG_fail;
11752 }
11753 {
11754 #if wxUSE_UNICODE
11755 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11756 #else
11757 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11758 #endif
11759 }
11760 return resultobj;
11761 fail:
11762 return NULL;
11763 }
11764
11765
11766 static PyObject * Locale_swigregister(PyObject *, PyObject *args) {
11767 PyObject *obj;
11768 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11769 SWIG_TypeClientData(SWIGTYPE_p_wxLocale, obj);
11770 Py_INCREF(obj);
11771 return Py_BuildValue((char *)"");
11772 }
11773 static PyObject *_wrap_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11774 PyObject *resultobj;
11775 wxLocale *result;
11776 char *kwnames[] = {
11777 NULL
11778 };
11779
11780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocale",kwnames)) goto fail;
11781 {
11782 PyThreadState* __tstate = wxPyBeginAllowThreads();
11783 result = (wxLocale *)wxGetLocale();
11784
11785 wxPyEndAllowThreads(__tstate);
11786 if (PyErr_Occurred()) SWIG_fail;
11787 }
11788 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 0);
11789 return resultobj;
11790 fail:
11791 return NULL;
11792 }
11793
11794
11795 static PyObject *_wrap_GetTranslation__SWIG_0(PyObject *, PyObject *args) {
11796 PyObject *resultobj;
11797 wxString *arg1 = 0 ;
11798 wxString result;
11799 bool temp1 = false ;
11800 PyObject * obj0 = 0 ;
11801
11802 if(!PyArg_ParseTuple(args,(char *)"O:GetTranslation",&obj0)) goto fail;
11803 {
11804 arg1 = wxString_in_helper(obj0);
11805 if (arg1 == NULL) SWIG_fail;
11806 temp1 = true;
11807 }
11808 {
11809 PyThreadState* __tstate = wxPyBeginAllowThreads();
11810 result = wxGetTranslation((wxString const &)*arg1);
11811
11812 wxPyEndAllowThreads(__tstate);
11813 if (PyErr_Occurred()) SWIG_fail;
11814 }
11815 {
11816 #if wxUSE_UNICODE
11817 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11818 #else
11819 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11820 #endif
11821 }
11822 {
11823 if (temp1)
11824 delete arg1;
11825 }
11826 return resultobj;
11827 fail:
11828 {
11829 if (temp1)
11830 delete arg1;
11831 }
11832 return NULL;
11833 }
11834
11835
11836 static PyObject *_wrap_GetTranslation__SWIG_1(PyObject *, PyObject *args) {
11837 PyObject *resultobj;
11838 wxString *arg1 = 0 ;
11839 wxString *arg2 = 0 ;
11840 size_t arg3 ;
11841 wxString result;
11842 bool temp1 = false ;
11843 bool temp2 = false ;
11844 PyObject * obj0 = 0 ;
11845 PyObject * obj1 = 0 ;
11846 PyObject * obj2 = 0 ;
11847
11848 if(!PyArg_ParseTuple(args,(char *)"OOO:GetTranslation",&obj0,&obj1,&obj2)) goto fail;
11849 {
11850 arg1 = wxString_in_helper(obj0);
11851 if (arg1 == NULL) SWIG_fail;
11852 temp1 = true;
11853 }
11854 {
11855 arg2 = wxString_in_helper(obj1);
11856 if (arg2 == NULL) SWIG_fail;
11857 temp2 = true;
11858 }
11859 {
11860 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
11861 if (SWIG_arg_fail(3)) SWIG_fail;
11862 }
11863 {
11864 PyThreadState* __tstate = wxPyBeginAllowThreads();
11865 result = wxGetTranslation((wxString const &)*arg1,(wxString const &)*arg2,arg3);
11866
11867 wxPyEndAllowThreads(__tstate);
11868 if (PyErr_Occurred()) SWIG_fail;
11869 }
11870 {
11871 #if wxUSE_UNICODE
11872 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11873 #else
11874 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11875 #endif
11876 }
11877 {
11878 if (temp1)
11879 delete arg1;
11880 }
11881 {
11882 if (temp2)
11883 delete arg2;
11884 }
11885 return resultobj;
11886 fail:
11887 {
11888 if (temp1)
11889 delete arg1;
11890 }
11891 {
11892 if (temp2)
11893 delete arg2;
11894 }
11895 return NULL;
11896 }
11897
11898
11899 static PyObject *_wrap_GetTranslation(PyObject *self, PyObject *args) {
11900 int argc;
11901 PyObject *argv[4];
11902 int ii;
11903
11904 argc = PyObject_Length(args);
11905 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
11906 argv[ii] = PyTuple_GetItem(args,ii);
11907 }
11908 if (argc == 1) {
11909 int _v;
11910 {
11911 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
11912 }
11913 if (_v) {
11914 return _wrap_GetTranslation__SWIG_0(self,args);
11915 }
11916 }
11917 if (argc == 3) {
11918 int _v;
11919 {
11920 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
11921 }
11922 if (_v) {
11923 {
11924 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
11925 }
11926 if (_v) {
11927 _v = SWIG_Check_unsigned_SS_long(argv[2]);
11928 if (_v) {
11929 return _wrap_GetTranslation__SWIG_1(self,args);
11930 }
11931 }
11932 }
11933 }
11934
11935 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GetTranslation'");
11936 return NULL;
11937 }
11938
11939
11940 static PyObject *_wrap_new_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
11941 PyObject *resultobj;
11942 wxEncodingConverter *result;
11943 char *kwnames[] = {
11944 NULL
11945 };
11946
11947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EncodingConverter",kwnames)) goto fail;
11948 {
11949 PyThreadState* __tstate = wxPyBeginAllowThreads();
11950 result = (wxEncodingConverter *)new wxEncodingConverter();
11951
11952 wxPyEndAllowThreads(__tstate);
11953 if (PyErr_Occurred()) SWIG_fail;
11954 }
11955 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEncodingConverter, 1);
11956 return resultobj;
11957 fail:
11958 return NULL;
11959 }
11960
11961
11962 static PyObject *_wrap_delete_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
11963 PyObject *resultobj;
11964 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
11965 PyObject * obj0 = 0 ;
11966 char *kwnames[] = {
11967 (char *) "self", NULL
11968 };
11969
11970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EncodingConverter",kwnames,&obj0)) goto fail;
11971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
11972 if (SWIG_arg_fail(1)) SWIG_fail;
11973 {
11974 PyThreadState* __tstate = wxPyBeginAllowThreads();
11975 delete arg1;
11976
11977 wxPyEndAllowThreads(__tstate);
11978 if (PyErr_Occurred()) SWIG_fail;
11979 }
11980 Py_INCREF(Py_None); resultobj = Py_None;
11981 return resultobj;
11982 fail:
11983 return NULL;
11984 }
11985
11986
11987 static PyObject *_wrap_EncodingConverter_Init(PyObject *, PyObject *args, PyObject *kwargs) {
11988 PyObject *resultobj;
11989 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
11990 wxFontEncoding arg2 ;
11991 wxFontEncoding arg3 ;
11992 int arg4 = (int) wxCONVERT_STRICT ;
11993 bool result;
11994 PyObject * obj0 = 0 ;
11995 PyObject * obj1 = 0 ;
11996 PyObject * obj2 = 0 ;
11997 PyObject * obj3 = 0 ;
11998 char *kwnames[] = {
11999 (char *) "self",(char *) "input_enc",(char *) "output_enc",(char *) "method", NULL
12000 };
12001
12002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:EncodingConverter_Init",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12004 if (SWIG_arg_fail(1)) SWIG_fail;
12005 {
12006 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12007 if (SWIG_arg_fail(2)) SWIG_fail;
12008 }
12009 {
12010 arg3 = (wxFontEncoding)(SWIG_As_int(obj2));
12011 if (SWIG_arg_fail(3)) SWIG_fail;
12012 }
12013 if (obj3) {
12014 {
12015 arg4 = (int)(SWIG_As_int(obj3));
12016 if (SWIG_arg_fail(4)) SWIG_fail;
12017 }
12018 }
12019 {
12020 PyThreadState* __tstate = wxPyBeginAllowThreads();
12021 result = (bool)(arg1)->Init((wxFontEncoding )arg2,(wxFontEncoding )arg3,arg4);
12022
12023 wxPyEndAllowThreads(__tstate);
12024 if (PyErr_Occurred()) SWIG_fail;
12025 }
12026 {
12027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12028 }
12029 return resultobj;
12030 fail:
12031 return NULL;
12032 }
12033
12034
12035 static PyObject *_wrap_EncodingConverter_Convert(PyObject *, PyObject *args, PyObject *kwargs) {
12036 PyObject *resultobj;
12037 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12038 wxString *arg2 = 0 ;
12039 wxString result;
12040 bool temp2 = false ;
12041 PyObject * obj0 = 0 ;
12042 PyObject * obj1 = 0 ;
12043 char *kwnames[] = {
12044 (char *) "self",(char *) "input", NULL
12045 };
12046
12047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_Convert",kwnames,&obj0,&obj1)) goto fail;
12048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12049 if (SWIG_arg_fail(1)) SWIG_fail;
12050 {
12051 arg2 = wxString_in_helper(obj1);
12052 if (arg2 == NULL) SWIG_fail;
12053 temp2 = true;
12054 }
12055 {
12056 PyThreadState* __tstate = wxPyBeginAllowThreads();
12057 result = (arg1)->Convert((wxString const &)*arg2);
12058
12059 wxPyEndAllowThreads(__tstate);
12060 if (PyErr_Occurred()) SWIG_fail;
12061 }
12062 {
12063 #if wxUSE_UNICODE
12064 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12065 #else
12066 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12067 #endif
12068 }
12069 {
12070 if (temp2)
12071 delete arg2;
12072 }
12073 return resultobj;
12074 fail:
12075 {
12076 if (temp2)
12077 delete arg2;
12078 }
12079 return NULL;
12080 }
12081
12082
12083 static PyObject *_wrap_EncodingConverter_GetPlatformEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12084 PyObject *resultobj;
12085 wxFontEncoding arg1 ;
12086 int arg2 = (int) wxPLATFORM_CURRENT ;
12087 wxFontEncodingArray result;
12088 PyObject * obj0 = 0 ;
12089 PyObject * obj1 = 0 ;
12090 char *kwnames[] = {
12091 (char *) "enc",(char *) "platform", NULL
12092 };
12093
12094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EncodingConverter_GetPlatformEquivalents",kwnames,&obj0,&obj1)) goto fail;
12095 {
12096 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12097 if (SWIG_arg_fail(1)) SWIG_fail;
12098 }
12099 if (obj1) {
12100 {
12101 arg2 = (int)(SWIG_As_int(obj1));
12102 if (SWIG_arg_fail(2)) SWIG_fail;
12103 }
12104 }
12105 {
12106 PyThreadState* __tstate = wxPyBeginAllowThreads();
12107 result = wxEncodingConverter::GetPlatformEquivalents((wxFontEncoding )arg1,arg2);
12108
12109 wxPyEndAllowThreads(__tstate);
12110 if (PyErr_Occurred()) SWIG_fail;
12111 }
12112 {
12113 resultobj = PyList_New(0);
12114 for (size_t i=0; i < (&result)->GetCount(); i++) {
12115 PyObject* number = PyInt_FromLong((&result)->Item(i));
12116 PyList_Append(resultobj, number);
12117 Py_DECREF(number);
12118 }
12119 }
12120 return resultobj;
12121 fail:
12122 return NULL;
12123 }
12124
12125
12126 static PyObject *_wrap_EncodingConverter_GetAllEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12127 PyObject *resultobj;
12128 wxFontEncoding arg1 ;
12129 wxFontEncodingArray result;
12130 PyObject * obj0 = 0 ;
12131 char *kwnames[] = {
12132 (char *) "enc", NULL
12133 };
12134
12135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EncodingConverter_GetAllEquivalents",kwnames,&obj0)) goto fail;
12136 {
12137 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12138 if (SWIG_arg_fail(1)) SWIG_fail;
12139 }
12140 {
12141 PyThreadState* __tstate = wxPyBeginAllowThreads();
12142 result = wxEncodingConverter::GetAllEquivalents((wxFontEncoding )arg1);
12143
12144 wxPyEndAllowThreads(__tstate);
12145 if (PyErr_Occurred()) SWIG_fail;
12146 }
12147 {
12148 resultobj = PyList_New(0);
12149 for (size_t i=0; i < (&result)->GetCount(); i++) {
12150 PyObject* number = PyInt_FromLong((&result)->Item(i));
12151 PyList_Append(resultobj, number);
12152 Py_DECREF(number);
12153 }
12154 }
12155 return resultobj;
12156 fail:
12157 return NULL;
12158 }
12159
12160
12161 static PyObject *_wrap_EncodingConverter_CanConvert(PyObject *, PyObject *args, PyObject *kwargs) {
12162 PyObject *resultobj;
12163 wxFontEncoding arg1 ;
12164 wxFontEncoding arg2 ;
12165 bool result;
12166 PyObject * obj0 = 0 ;
12167 PyObject * obj1 = 0 ;
12168 char *kwnames[] = {
12169 (char *) "encIn",(char *) "encOut", NULL
12170 };
12171
12172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_CanConvert",kwnames,&obj0,&obj1)) goto fail;
12173 {
12174 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12175 if (SWIG_arg_fail(1)) SWIG_fail;
12176 }
12177 {
12178 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12179 if (SWIG_arg_fail(2)) SWIG_fail;
12180 }
12181 {
12182 PyThreadState* __tstate = wxPyBeginAllowThreads();
12183 result = (bool)wxEncodingConverter::CanConvert((wxFontEncoding )arg1,(wxFontEncoding )arg2);
12184
12185 wxPyEndAllowThreads(__tstate);
12186 if (PyErr_Occurred()) SWIG_fail;
12187 }
12188 {
12189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12190 }
12191 return resultobj;
12192 fail:
12193 return NULL;
12194 }
12195
12196
12197 static PyObject * EncodingConverter_swigregister(PyObject *, PyObject *args) {
12198 PyObject *obj;
12199 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12200 SWIG_TypeClientData(SWIGTYPE_p_wxEncodingConverter, obj);
12201 Py_INCREF(obj);
12202 return Py_BuildValue((char *)"");
12203 }
12204 static PyObject *_wrap_delete_DC(PyObject *, PyObject *args, PyObject *kwargs) {
12205 PyObject *resultobj;
12206 wxDC *arg1 = (wxDC *) 0 ;
12207 PyObject * obj0 = 0 ;
12208 char *kwnames[] = {
12209 (char *) "self", NULL
12210 };
12211
12212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DC",kwnames,&obj0)) goto fail;
12213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12214 if (SWIG_arg_fail(1)) SWIG_fail;
12215 {
12216 PyThreadState* __tstate = wxPyBeginAllowThreads();
12217 delete arg1;
12218
12219 wxPyEndAllowThreads(__tstate);
12220 if (PyErr_Occurred()) SWIG_fail;
12221 }
12222 Py_INCREF(Py_None); resultobj = Py_None;
12223 return resultobj;
12224 fail:
12225 return NULL;
12226 }
12227
12228
12229 static PyObject *_wrap_DC_BeginDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12230 PyObject *resultobj;
12231 wxDC *arg1 = (wxDC *) 0 ;
12232 PyObject * obj0 = 0 ;
12233 char *kwnames[] = {
12234 (char *) "self", NULL
12235 };
12236
12237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_BeginDrawing",kwnames,&obj0)) goto fail;
12238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12239 if (SWIG_arg_fail(1)) SWIG_fail;
12240 {
12241 PyThreadState* __tstate = wxPyBeginAllowThreads();
12242 (arg1)->BeginDrawing();
12243
12244 wxPyEndAllowThreads(__tstate);
12245 if (PyErr_Occurred()) SWIG_fail;
12246 }
12247 Py_INCREF(Py_None); resultobj = Py_None;
12248 return resultobj;
12249 fail:
12250 return NULL;
12251 }
12252
12253
12254 static PyObject *_wrap_DC_EndDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12255 PyObject *resultobj;
12256 wxDC *arg1 = (wxDC *) 0 ;
12257 PyObject * obj0 = 0 ;
12258 char *kwnames[] = {
12259 (char *) "self", NULL
12260 };
12261
12262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDrawing",kwnames,&obj0)) goto fail;
12263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12264 if (SWIG_arg_fail(1)) SWIG_fail;
12265 {
12266 PyThreadState* __tstate = wxPyBeginAllowThreads();
12267 (arg1)->EndDrawing();
12268
12269 wxPyEndAllowThreads(__tstate);
12270 if (PyErr_Occurred()) SWIG_fail;
12271 }
12272 Py_INCREF(Py_None); resultobj = Py_None;
12273 return resultobj;
12274 fail:
12275 return NULL;
12276 }
12277
12278
12279 static PyObject *_wrap_DC_FloodFill(PyObject *, PyObject *args, PyObject *kwargs) {
12280 PyObject *resultobj;
12281 wxDC *arg1 = (wxDC *) 0 ;
12282 int arg2 ;
12283 int arg3 ;
12284 wxColour *arg4 = 0 ;
12285 int arg5 = (int) wxFLOOD_SURFACE ;
12286 bool result;
12287 wxColour temp4 ;
12288 PyObject * obj0 = 0 ;
12289 PyObject * obj1 = 0 ;
12290 PyObject * obj2 = 0 ;
12291 PyObject * obj3 = 0 ;
12292 PyObject * obj4 = 0 ;
12293 char *kwnames[] = {
12294 (char *) "self",(char *) "x",(char *) "y",(char *) "col",(char *) "style", NULL
12295 };
12296
12297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_FloodFill",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12299 if (SWIG_arg_fail(1)) SWIG_fail;
12300 {
12301 arg2 = (int)(SWIG_As_int(obj1));
12302 if (SWIG_arg_fail(2)) SWIG_fail;
12303 }
12304 {
12305 arg3 = (int)(SWIG_As_int(obj2));
12306 if (SWIG_arg_fail(3)) SWIG_fail;
12307 }
12308 {
12309 arg4 = &temp4;
12310 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
12311 }
12312 if (obj4) {
12313 {
12314 arg5 = (int)(SWIG_As_int(obj4));
12315 if (SWIG_arg_fail(5)) SWIG_fail;
12316 }
12317 }
12318 {
12319 PyThreadState* __tstate = wxPyBeginAllowThreads();
12320 result = (bool)(arg1)->FloodFill(arg2,arg3,(wxColour const &)*arg4,arg5);
12321
12322 wxPyEndAllowThreads(__tstate);
12323 if (PyErr_Occurred()) SWIG_fail;
12324 }
12325 {
12326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12327 }
12328 return resultobj;
12329 fail:
12330 return NULL;
12331 }
12332
12333
12334 static PyObject *_wrap_DC_FloodFillPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12335 PyObject *resultobj;
12336 wxDC *arg1 = (wxDC *) 0 ;
12337 wxPoint *arg2 = 0 ;
12338 wxColour *arg3 = 0 ;
12339 int arg4 = (int) wxFLOOD_SURFACE ;
12340 bool result;
12341 wxPoint temp2 ;
12342 wxColour temp3 ;
12343 PyObject * obj0 = 0 ;
12344 PyObject * obj1 = 0 ;
12345 PyObject * obj2 = 0 ;
12346 PyObject * obj3 = 0 ;
12347 char *kwnames[] = {
12348 (char *) "self",(char *) "pt",(char *) "col",(char *) "style", NULL
12349 };
12350
12351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_FloodFillPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12353 if (SWIG_arg_fail(1)) SWIG_fail;
12354 {
12355 arg2 = &temp2;
12356 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12357 }
12358 {
12359 arg3 = &temp3;
12360 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
12361 }
12362 if (obj3) {
12363 {
12364 arg4 = (int)(SWIG_As_int(obj3));
12365 if (SWIG_arg_fail(4)) SWIG_fail;
12366 }
12367 }
12368 {
12369 PyThreadState* __tstate = wxPyBeginAllowThreads();
12370 result = (bool)(arg1)->FloodFill((wxPoint const &)*arg2,(wxColour const &)*arg3,arg4);
12371
12372 wxPyEndAllowThreads(__tstate);
12373 if (PyErr_Occurred()) SWIG_fail;
12374 }
12375 {
12376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12377 }
12378 return resultobj;
12379 fail:
12380 return NULL;
12381 }
12382
12383
12384 static PyObject *_wrap_DC_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
12385 PyObject *resultobj;
12386 wxDC *arg1 = (wxDC *) 0 ;
12387 int arg2 ;
12388 int arg3 ;
12389 wxColour result;
12390 PyObject * obj0 = 0 ;
12391 PyObject * obj1 = 0 ;
12392 PyObject * obj2 = 0 ;
12393 char *kwnames[] = {
12394 (char *) "self",(char *) "x",(char *) "y", NULL
12395 };
12396
12397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_GetPixel",kwnames,&obj0,&obj1,&obj2)) goto fail;
12398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12399 if (SWIG_arg_fail(1)) SWIG_fail;
12400 {
12401 arg2 = (int)(SWIG_As_int(obj1));
12402 if (SWIG_arg_fail(2)) SWIG_fail;
12403 }
12404 {
12405 arg3 = (int)(SWIG_As_int(obj2));
12406 if (SWIG_arg_fail(3)) SWIG_fail;
12407 }
12408 {
12409 PyThreadState* __tstate = wxPyBeginAllowThreads();
12410 result = wxDC_GetPixel(arg1,arg2,arg3);
12411
12412 wxPyEndAllowThreads(__tstate);
12413 if (PyErr_Occurred()) SWIG_fail;
12414 }
12415 {
12416 wxColour * resultptr;
12417 resultptr = new wxColour((wxColour &)(result));
12418 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12419 }
12420 return resultobj;
12421 fail:
12422 return NULL;
12423 }
12424
12425
12426 static PyObject *_wrap_DC_GetPixelPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12427 PyObject *resultobj;
12428 wxDC *arg1 = (wxDC *) 0 ;
12429 wxPoint *arg2 = 0 ;
12430 wxColour result;
12431 wxPoint temp2 ;
12432 PyObject * obj0 = 0 ;
12433 PyObject * obj1 = 0 ;
12434 char *kwnames[] = {
12435 (char *) "self",(char *) "pt", NULL
12436 };
12437
12438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPixelPoint",kwnames,&obj0,&obj1)) goto fail;
12439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12440 if (SWIG_arg_fail(1)) SWIG_fail;
12441 {
12442 arg2 = &temp2;
12443 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12444 }
12445 {
12446 PyThreadState* __tstate = wxPyBeginAllowThreads();
12447 result = wxDC_GetPixelPoint(arg1,(wxPoint const &)*arg2);
12448
12449 wxPyEndAllowThreads(__tstate);
12450 if (PyErr_Occurred()) SWIG_fail;
12451 }
12452 {
12453 wxColour * resultptr;
12454 resultptr = new wxColour((wxColour &)(result));
12455 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12456 }
12457 return resultobj;
12458 fail:
12459 return NULL;
12460 }
12461
12462
12463 static PyObject *_wrap_DC_DrawLine(PyObject *, PyObject *args, PyObject *kwargs) {
12464 PyObject *resultobj;
12465 wxDC *arg1 = (wxDC *) 0 ;
12466 int arg2 ;
12467 int arg3 ;
12468 int arg4 ;
12469 int arg5 ;
12470 PyObject * obj0 = 0 ;
12471 PyObject * obj1 = 0 ;
12472 PyObject * obj2 = 0 ;
12473 PyObject * obj3 = 0 ;
12474 PyObject * obj4 = 0 ;
12475 char *kwnames[] = {
12476 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2", NULL
12477 };
12478
12479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12481 if (SWIG_arg_fail(1)) SWIG_fail;
12482 {
12483 arg2 = (int)(SWIG_As_int(obj1));
12484 if (SWIG_arg_fail(2)) SWIG_fail;
12485 }
12486 {
12487 arg3 = (int)(SWIG_As_int(obj2));
12488 if (SWIG_arg_fail(3)) SWIG_fail;
12489 }
12490 {
12491 arg4 = (int)(SWIG_As_int(obj3));
12492 if (SWIG_arg_fail(4)) SWIG_fail;
12493 }
12494 {
12495 arg5 = (int)(SWIG_As_int(obj4));
12496 if (SWIG_arg_fail(5)) SWIG_fail;
12497 }
12498 {
12499 PyThreadState* __tstate = wxPyBeginAllowThreads();
12500 (arg1)->DrawLine(arg2,arg3,arg4,arg5);
12501
12502 wxPyEndAllowThreads(__tstate);
12503 if (PyErr_Occurred()) SWIG_fail;
12504 }
12505 Py_INCREF(Py_None); resultobj = Py_None;
12506 return resultobj;
12507 fail:
12508 return NULL;
12509 }
12510
12511
12512 static PyObject *_wrap_DC_DrawLinePoint(PyObject *, PyObject *args, PyObject *kwargs) {
12513 PyObject *resultobj;
12514 wxDC *arg1 = (wxDC *) 0 ;
12515 wxPoint *arg2 = 0 ;
12516 wxPoint *arg3 = 0 ;
12517 wxPoint temp2 ;
12518 wxPoint temp3 ;
12519 PyObject * obj0 = 0 ;
12520 PyObject * obj1 = 0 ;
12521 PyObject * obj2 = 0 ;
12522 char *kwnames[] = {
12523 (char *) "self",(char *) "pt1",(char *) "pt2", NULL
12524 };
12525
12526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawLinePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
12527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12528 if (SWIG_arg_fail(1)) SWIG_fail;
12529 {
12530 arg2 = &temp2;
12531 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12532 }
12533 {
12534 arg3 = &temp3;
12535 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12536 }
12537 {
12538 PyThreadState* __tstate = wxPyBeginAllowThreads();
12539 (arg1)->DrawLine((wxPoint const &)*arg2,(wxPoint const &)*arg3);
12540
12541 wxPyEndAllowThreads(__tstate);
12542 if (PyErr_Occurred()) SWIG_fail;
12543 }
12544 Py_INCREF(Py_None); resultobj = Py_None;
12545 return resultobj;
12546 fail:
12547 return NULL;
12548 }
12549
12550
12551 static PyObject *_wrap_DC_CrossHair(PyObject *, PyObject *args, PyObject *kwargs) {
12552 PyObject *resultobj;
12553 wxDC *arg1 = (wxDC *) 0 ;
12554 int arg2 ;
12555 int arg3 ;
12556 PyObject * obj0 = 0 ;
12557 PyObject * obj1 = 0 ;
12558 PyObject * obj2 = 0 ;
12559 char *kwnames[] = {
12560 (char *) "self",(char *) "x",(char *) "y", NULL
12561 };
12562
12563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CrossHair",kwnames,&obj0,&obj1,&obj2)) goto fail;
12564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12565 if (SWIG_arg_fail(1)) SWIG_fail;
12566 {
12567 arg2 = (int)(SWIG_As_int(obj1));
12568 if (SWIG_arg_fail(2)) SWIG_fail;
12569 }
12570 {
12571 arg3 = (int)(SWIG_As_int(obj2));
12572 if (SWIG_arg_fail(3)) SWIG_fail;
12573 }
12574 {
12575 PyThreadState* __tstate = wxPyBeginAllowThreads();
12576 (arg1)->CrossHair(arg2,arg3);
12577
12578 wxPyEndAllowThreads(__tstate);
12579 if (PyErr_Occurred()) SWIG_fail;
12580 }
12581 Py_INCREF(Py_None); resultobj = Py_None;
12582 return resultobj;
12583 fail:
12584 return NULL;
12585 }
12586
12587
12588 static PyObject *_wrap_DC_CrossHairPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12589 PyObject *resultobj;
12590 wxDC *arg1 = (wxDC *) 0 ;
12591 wxPoint *arg2 = 0 ;
12592 wxPoint temp2 ;
12593 PyObject * obj0 = 0 ;
12594 PyObject * obj1 = 0 ;
12595 char *kwnames[] = {
12596 (char *) "self",(char *) "pt", NULL
12597 };
12598
12599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CrossHairPoint",kwnames,&obj0,&obj1)) goto fail;
12600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12601 if (SWIG_arg_fail(1)) SWIG_fail;
12602 {
12603 arg2 = &temp2;
12604 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12605 }
12606 {
12607 PyThreadState* __tstate = wxPyBeginAllowThreads();
12608 (arg1)->CrossHair((wxPoint const &)*arg2);
12609
12610 wxPyEndAllowThreads(__tstate);
12611 if (PyErr_Occurred()) SWIG_fail;
12612 }
12613 Py_INCREF(Py_None); resultobj = Py_None;
12614 return resultobj;
12615 fail:
12616 return NULL;
12617 }
12618
12619
12620 static PyObject *_wrap_DC_DrawArc(PyObject *, PyObject *args, PyObject *kwargs) {
12621 PyObject *resultobj;
12622 wxDC *arg1 = (wxDC *) 0 ;
12623 int arg2 ;
12624 int arg3 ;
12625 int arg4 ;
12626 int arg5 ;
12627 int arg6 ;
12628 int arg7 ;
12629 PyObject * obj0 = 0 ;
12630 PyObject * obj1 = 0 ;
12631 PyObject * obj2 = 0 ;
12632 PyObject * obj3 = 0 ;
12633 PyObject * obj4 = 0 ;
12634 PyObject * obj5 = 0 ;
12635 PyObject * obj6 = 0 ;
12636 char *kwnames[] = {
12637 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2",(char *) "xc",(char *) "yc", NULL
12638 };
12639
12640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12642 if (SWIG_arg_fail(1)) SWIG_fail;
12643 {
12644 arg2 = (int)(SWIG_As_int(obj1));
12645 if (SWIG_arg_fail(2)) SWIG_fail;
12646 }
12647 {
12648 arg3 = (int)(SWIG_As_int(obj2));
12649 if (SWIG_arg_fail(3)) SWIG_fail;
12650 }
12651 {
12652 arg4 = (int)(SWIG_As_int(obj3));
12653 if (SWIG_arg_fail(4)) SWIG_fail;
12654 }
12655 {
12656 arg5 = (int)(SWIG_As_int(obj4));
12657 if (SWIG_arg_fail(5)) SWIG_fail;
12658 }
12659 {
12660 arg6 = (int)(SWIG_As_int(obj5));
12661 if (SWIG_arg_fail(6)) SWIG_fail;
12662 }
12663 {
12664 arg7 = (int)(SWIG_As_int(obj6));
12665 if (SWIG_arg_fail(7)) SWIG_fail;
12666 }
12667 {
12668 PyThreadState* __tstate = wxPyBeginAllowThreads();
12669 (arg1)->DrawArc(arg2,arg3,arg4,arg5,arg6,arg7);
12670
12671 wxPyEndAllowThreads(__tstate);
12672 if (PyErr_Occurred()) SWIG_fail;
12673 }
12674 Py_INCREF(Py_None); resultobj = Py_None;
12675 return resultobj;
12676 fail:
12677 return NULL;
12678 }
12679
12680
12681 static PyObject *_wrap_DC_DrawArcPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12682 PyObject *resultobj;
12683 wxDC *arg1 = (wxDC *) 0 ;
12684 wxPoint *arg2 = 0 ;
12685 wxPoint *arg3 = 0 ;
12686 wxPoint *arg4 = 0 ;
12687 wxPoint temp2 ;
12688 wxPoint temp3 ;
12689 wxPoint temp4 ;
12690 PyObject * obj0 = 0 ;
12691 PyObject * obj1 = 0 ;
12692 PyObject * obj2 = 0 ;
12693 PyObject * obj3 = 0 ;
12694 char *kwnames[] = {
12695 (char *) "self",(char *) "pt1",(char *) "pt2",(char *) "center", NULL
12696 };
12697
12698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawArcPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12700 if (SWIG_arg_fail(1)) SWIG_fail;
12701 {
12702 arg2 = &temp2;
12703 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12704 }
12705 {
12706 arg3 = &temp3;
12707 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12708 }
12709 {
12710 arg4 = &temp4;
12711 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
12712 }
12713 {
12714 PyThreadState* __tstate = wxPyBeginAllowThreads();
12715 (arg1)->DrawArc((wxPoint const &)*arg2,(wxPoint const &)*arg3,(wxPoint const &)*arg4);
12716
12717 wxPyEndAllowThreads(__tstate);
12718 if (PyErr_Occurred()) SWIG_fail;
12719 }
12720 Py_INCREF(Py_None); resultobj = Py_None;
12721 return resultobj;
12722 fail:
12723 return NULL;
12724 }
12725
12726
12727 static PyObject *_wrap_DC_DrawCheckMark(PyObject *, PyObject *args, PyObject *kwargs) {
12728 PyObject *resultobj;
12729 wxDC *arg1 = (wxDC *) 0 ;
12730 int arg2 ;
12731 int arg3 ;
12732 int arg4 ;
12733 int arg5 ;
12734 PyObject * obj0 = 0 ;
12735 PyObject * obj1 = 0 ;
12736 PyObject * obj2 = 0 ;
12737 PyObject * obj3 = 0 ;
12738 PyObject * obj4 = 0 ;
12739 char *kwnames[] = {
12740 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
12741 };
12742
12743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawCheckMark",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12745 if (SWIG_arg_fail(1)) SWIG_fail;
12746 {
12747 arg2 = (int)(SWIG_As_int(obj1));
12748 if (SWIG_arg_fail(2)) SWIG_fail;
12749 }
12750 {
12751 arg3 = (int)(SWIG_As_int(obj2));
12752 if (SWIG_arg_fail(3)) SWIG_fail;
12753 }
12754 {
12755 arg4 = (int)(SWIG_As_int(obj3));
12756 if (SWIG_arg_fail(4)) SWIG_fail;
12757 }
12758 {
12759 arg5 = (int)(SWIG_As_int(obj4));
12760 if (SWIG_arg_fail(5)) SWIG_fail;
12761 }
12762 {
12763 PyThreadState* __tstate = wxPyBeginAllowThreads();
12764 (arg1)->DrawCheckMark(arg2,arg3,arg4,arg5);
12765
12766 wxPyEndAllowThreads(__tstate);
12767 if (PyErr_Occurred()) SWIG_fail;
12768 }
12769 Py_INCREF(Py_None); resultobj = Py_None;
12770 return resultobj;
12771 fail:
12772 return NULL;
12773 }
12774
12775
12776 static PyObject *_wrap_DC_DrawCheckMarkRect(PyObject *, PyObject *args, PyObject *kwargs) {
12777 PyObject *resultobj;
12778 wxDC *arg1 = (wxDC *) 0 ;
12779 wxRect *arg2 = 0 ;
12780 wxRect temp2 ;
12781 PyObject * obj0 = 0 ;
12782 PyObject * obj1 = 0 ;
12783 char *kwnames[] = {
12784 (char *) "self",(char *) "rect", NULL
12785 };
12786
12787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawCheckMarkRect",kwnames,&obj0,&obj1)) goto fail;
12788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12789 if (SWIG_arg_fail(1)) SWIG_fail;
12790 {
12791 arg2 = &temp2;
12792 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12793 }
12794 {
12795 PyThreadState* __tstate = wxPyBeginAllowThreads();
12796 (arg1)->DrawCheckMark((wxRect const &)*arg2);
12797
12798 wxPyEndAllowThreads(__tstate);
12799 if (PyErr_Occurred()) SWIG_fail;
12800 }
12801 Py_INCREF(Py_None); resultobj = Py_None;
12802 return resultobj;
12803 fail:
12804 return NULL;
12805 }
12806
12807
12808 static PyObject *_wrap_DC_DrawEllipticArc(PyObject *, PyObject *args, PyObject *kwargs) {
12809 PyObject *resultobj;
12810 wxDC *arg1 = (wxDC *) 0 ;
12811 int arg2 ;
12812 int arg3 ;
12813 int arg4 ;
12814 int arg5 ;
12815 double arg6 ;
12816 double arg7 ;
12817 PyObject * obj0 = 0 ;
12818 PyObject * obj1 = 0 ;
12819 PyObject * obj2 = 0 ;
12820 PyObject * obj3 = 0 ;
12821 PyObject * obj4 = 0 ;
12822 PyObject * obj5 = 0 ;
12823 PyObject * obj6 = 0 ;
12824 char *kwnames[] = {
12825 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h",(char *) "start",(char *) "end", NULL
12826 };
12827
12828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawEllipticArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12830 if (SWIG_arg_fail(1)) SWIG_fail;
12831 {
12832 arg2 = (int)(SWIG_As_int(obj1));
12833 if (SWIG_arg_fail(2)) SWIG_fail;
12834 }
12835 {
12836 arg3 = (int)(SWIG_As_int(obj2));
12837 if (SWIG_arg_fail(3)) SWIG_fail;
12838 }
12839 {
12840 arg4 = (int)(SWIG_As_int(obj3));
12841 if (SWIG_arg_fail(4)) SWIG_fail;
12842 }
12843 {
12844 arg5 = (int)(SWIG_As_int(obj4));
12845 if (SWIG_arg_fail(5)) SWIG_fail;
12846 }
12847 {
12848 arg6 = (double)(SWIG_As_double(obj5));
12849 if (SWIG_arg_fail(6)) SWIG_fail;
12850 }
12851 {
12852 arg7 = (double)(SWIG_As_double(obj6));
12853 if (SWIG_arg_fail(7)) SWIG_fail;
12854 }
12855 {
12856 PyThreadState* __tstate = wxPyBeginAllowThreads();
12857 (arg1)->DrawEllipticArc(arg2,arg3,arg4,arg5,arg6,arg7);
12858
12859 wxPyEndAllowThreads(__tstate);
12860 if (PyErr_Occurred()) SWIG_fail;
12861 }
12862 Py_INCREF(Py_None); resultobj = Py_None;
12863 return resultobj;
12864 fail:
12865 return NULL;
12866 }
12867
12868
12869 static PyObject *_wrap_DC_DrawEllipticArcPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
12870 PyObject *resultobj;
12871 wxDC *arg1 = (wxDC *) 0 ;
12872 wxPoint *arg2 = 0 ;
12873 wxSize *arg3 = 0 ;
12874 double arg4 ;
12875 double arg5 ;
12876 wxPoint temp2 ;
12877 wxSize temp3 ;
12878 PyObject * obj0 = 0 ;
12879 PyObject * obj1 = 0 ;
12880 PyObject * obj2 = 0 ;
12881 PyObject * obj3 = 0 ;
12882 PyObject * obj4 = 0 ;
12883 char *kwnames[] = {
12884 (char *) "self",(char *) "pt",(char *) "sz",(char *) "start",(char *) "end", NULL
12885 };
12886
12887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipticArcPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12889 if (SWIG_arg_fail(1)) SWIG_fail;
12890 {
12891 arg2 = &temp2;
12892 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12893 }
12894 {
12895 arg3 = &temp3;
12896 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
12897 }
12898 {
12899 arg4 = (double)(SWIG_As_double(obj3));
12900 if (SWIG_arg_fail(4)) SWIG_fail;
12901 }
12902 {
12903 arg5 = (double)(SWIG_As_double(obj4));
12904 if (SWIG_arg_fail(5)) SWIG_fail;
12905 }
12906 {
12907 PyThreadState* __tstate = wxPyBeginAllowThreads();
12908 (arg1)->DrawEllipticArc((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,arg5);
12909
12910 wxPyEndAllowThreads(__tstate);
12911 if (PyErr_Occurred()) SWIG_fail;
12912 }
12913 Py_INCREF(Py_None); resultobj = Py_None;
12914 return resultobj;
12915 fail:
12916 return NULL;
12917 }
12918
12919
12920 static PyObject *_wrap_DC_DrawPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12921 PyObject *resultobj;
12922 wxDC *arg1 = (wxDC *) 0 ;
12923 int arg2 ;
12924 int arg3 ;
12925 PyObject * obj0 = 0 ;
12926 PyObject * obj1 = 0 ;
12927 PyObject * obj2 = 0 ;
12928 char *kwnames[] = {
12929 (char *) "self",(char *) "x",(char *) "y", NULL
12930 };
12931
12932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
12933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12934 if (SWIG_arg_fail(1)) SWIG_fail;
12935 {
12936 arg2 = (int)(SWIG_As_int(obj1));
12937 if (SWIG_arg_fail(2)) SWIG_fail;
12938 }
12939 {
12940 arg3 = (int)(SWIG_As_int(obj2));
12941 if (SWIG_arg_fail(3)) SWIG_fail;
12942 }
12943 {
12944 PyThreadState* __tstate = wxPyBeginAllowThreads();
12945 (arg1)->DrawPoint(arg2,arg3);
12946
12947 wxPyEndAllowThreads(__tstate);
12948 if (PyErr_Occurred()) SWIG_fail;
12949 }
12950 Py_INCREF(Py_None); resultobj = Py_None;
12951 return resultobj;
12952 fail:
12953 return NULL;
12954 }
12955
12956
12957 static PyObject *_wrap_DC_DrawPointPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12958 PyObject *resultobj;
12959 wxDC *arg1 = (wxDC *) 0 ;
12960 wxPoint *arg2 = 0 ;
12961 wxPoint temp2 ;
12962 PyObject * obj0 = 0 ;
12963 PyObject * obj1 = 0 ;
12964 char *kwnames[] = {
12965 (char *) "self",(char *) "pt", NULL
12966 };
12967
12968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawPointPoint",kwnames,&obj0,&obj1)) goto fail;
12969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12970 if (SWIG_arg_fail(1)) SWIG_fail;
12971 {
12972 arg2 = &temp2;
12973 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12974 }
12975 {
12976 PyThreadState* __tstate = wxPyBeginAllowThreads();
12977 (arg1)->DrawPoint((wxPoint const &)*arg2);
12978
12979 wxPyEndAllowThreads(__tstate);
12980 if (PyErr_Occurred()) SWIG_fail;
12981 }
12982 Py_INCREF(Py_None); resultobj = Py_None;
12983 return resultobj;
12984 fail:
12985 return NULL;
12986 }
12987
12988
12989 static PyObject *_wrap_DC_DrawRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
12990 PyObject *resultobj;
12991 wxDC *arg1 = (wxDC *) 0 ;
12992 int arg2 ;
12993 int arg3 ;
12994 int arg4 ;
12995 int arg5 ;
12996 PyObject * obj0 = 0 ;
12997 PyObject * obj1 = 0 ;
12998 PyObject * obj2 = 0 ;
12999 PyObject * obj3 = 0 ;
13000 PyObject * obj4 = 0 ;
13001 char *kwnames[] = {
13002 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13003 };
13004
13005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13007 if (SWIG_arg_fail(1)) SWIG_fail;
13008 {
13009 arg2 = (int)(SWIG_As_int(obj1));
13010 if (SWIG_arg_fail(2)) SWIG_fail;
13011 }
13012 {
13013 arg3 = (int)(SWIG_As_int(obj2));
13014 if (SWIG_arg_fail(3)) SWIG_fail;
13015 }
13016 {
13017 arg4 = (int)(SWIG_As_int(obj3));
13018 if (SWIG_arg_fail(4)) SWIG_fail;
13019 }
13020 {
13021 arg5 = (int)(SWIG_As_int(obj4));
13022 if (SWIG_arg_fail(5)) SWIG_fail;
13023 }
13024 {
13025 PyThreadState* __tstate = wxPyBeginAllowThreads();
13026 (arg1)->DrawRectangle(arg2,arg3,arg4,arg5);
13027
13028 wxPyEndAllowThreads(__tstate);
13029 if (PyErr_Occurred()) SWIG_fail;
13030 }
13031 Py_INCREF(Py_None); resultobj = Py_None;
13032 return resultobj;
13033 fail:
13034 return NULL;
13035 }
13036
13037
13038 static PyObject *_wrap_DC_DrawRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13039 PyObject *resultobj;
13040 wxDC *arg1 = (wxDC *) 0 ;
13041 wxRect *arg2 = 0 ;
13042 wxRect temp2 ;
13043 PyObject * obj0 = 0 ;
13044 PyObject * obj1 = 0 ;
13045 char *kwnames[] = {
13046 (char *) "self",(char *) "rect", NULL
13047 };
13048
13049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawRectangleRect",kwnames,&obj0,&obj1)) goto fail;
13050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13051 if (SWIG_arg_fail(1)) SWIG_fail;
13052 {
13053 arg2 = &temp2;
13054 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13055 }
13056 {
13057 PyThreadState* __tstate = wxPyBeginAllowThreads();
13058 (arg1)->DrawRectangle((wxRect const &)*arg2);
13059
13060 wxPyEndAllowThreads(__tstate);
13061 if (PyErr_Occurred()) SWIG_fail;
13062 }
13063 Py_INCREF(Py_None); resultobj = Py_None;
13064 return resultobj;
13065 fail:
13066 return NULL;
13067 }
13068
13069
13070 static PyObject *_wrap_DC_DrawRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13071 PyObject *resultobj;
13072 wxDC *arg1 = (wxDC *) 0 ;
13073 wxPoint *arg2 = 0 ;
13074 wxSize *arg3 = 0 ;
13075 wxPoint temp2 ;
13076 wxSize temp3 ;
13077 PyObject * obj0 = 0 ;
13078 PyObject * obj1 = 0 ;
13079 PyObject * obj2 = 0 ;
13080 char *kwnames[] = {
13081 (char *) "self",(char *) "pt",(char *) "sz", NULL
13082 };
13083
13084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRectanglePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13086 if (SWIG_arg_fail(1)) SWIG_fail;
13087 {
13088 arg2 = &temp2;
13089 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13090 }
13091 {
13092 arg3 = &temp3;
13093 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13094 }
13095 {
13096 PyThreadState* __tstate = wxPyBeginAllowThreads();
13097 (arg1)->DrawRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3);
13098
13099 wxPyEndAllowThreads(__tstate);
13100 if (PyErr_Occurred()) SWIG_fail;
13101 }
13102 Py_INCREF(Py_None); resultobj = Py_None;
13103 return resultobj;
13104 fail:
13105 return NULL;
13106 }
13107
13108
13109 static PyObject *_wrap_DC_DrawRoundedRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13110 PyObject *resultobj;
13111 wxDC *arg1 = (wxDC *) 0 ;
13112 int arg2 ;
13113 int arg3 ;
13114 int arg4 ;
13115 int arg5 ;
13116 double arg6 ;
13117 PyObject * obj0 = 0 ;
13118 PyObject * obj1 = 0 ;
13119 PyObject * obj2 = 0 ;
13120 PyObject * obj3 = 0 ;
13121 PyObject * obj4 = 0 ;
13122 PyObject * obj5 = 0 ;
13123 char *kwnames[] = {
13124 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "radius", NULL
13125 };
13126
13127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:DC_DrawRoundedRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
13128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13129 if (SWIG_arg_fail(1)) SWIG_fail;
13130 {
13131 arg2 = (int)(SWIG_As_int(obj1));
13132 if (SWIG_arg_fail(2)) SWIG_fail;
13133 }
13134 {
13135 arg3 = (int)(SWIG_As_int(obj2));
13136 if (SWIG_arg_fail(3)) SWIG_fail;
13137 }
13138 {
13139 arg4 = (int)(SWIG_As_int(obj3));
13140 if (SWIG_arg_fail(4)) SWIG_fail;
13141 }
13142 {
13143 arg5 = (int)(SWIG_As_int(obj4));
13144 if (SWIG_arg_fail(5)) SWIG_fail;
13145 }
13146 {
13147 arg6 = (double)(SWIG_As_double(obj5));
13148 if (SWIG_arg_fail(6)) SWIG_fail;
13149 }
13150 {
13151 PyThreadState* __tstate = wxPyBeginAllowThreads();
13152 (arg1)->DrawRoundedRectangle(arg2,arg3,arg4,arg5,arg6);
13153
13154 wxPyEndAllowThreads(__tstate);
13155 if (PyErr_Occurred()) SWIG_fail;
13156 }
13157 Py_INCREF(Py_None); resultobj = Py_None;
13158 return resultobj;
13159 fail:
13160 return NULL;
13161 }
13162
13163
13164 static PyObject *_wrap_DC_DrawRoundedRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13165 PyObject *resultobj;
13166 wxDC *arg1 = (wxDC *) 0 ;
13167 wxRect *arg2 = 0 ;
13168 double arg3 ;
13169 wxRect temp2 ;
13170 PyObject * obj0 = 0 ;
13171 PyObject * obj1 = 0 ;
13172 PyObject * obj2 = 0 ;
13173 char *kwnames[] = {
13174 (char *) "self",(char *) "r",(char *) "radius", NULL
13175 };
13176
13177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRoundedRectangleRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
13178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13179 if (SWIG_arg_fail(1)) SWIG_fail;
13180 {
13181 arg2 = &temp2;
13182 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13183 }
13184 {
13185 arg3 = (double)(SWIG_As_double(obj2));
13186 if (SWIG_arg_fail(3)) SWIG_fail;
13187 }
13188 {
13189 PyThreadState* __tstate = wxPyBeginAllowThreads();
13190 (arg1)->DrawRoundedRectangle((wxRect const &)*arg2,arg3);
13191
13192 wxPyEndAllowThreads(__tstate);
13193 if (PyErr_Occurred()) SWIG_fail;
13194 }
13195 Py_INCREF(Py_None); resultobj = Py_None;
13196 return resultobj;
13197 fail:
13198 return NULL;
13199 }
13200
13201
13202 static PyObject *_wrap_DC_DrawRoundedRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13203 PyObject *resultobj;
13204 wxDC *arg1 = (wxDC *) 0 ;
13205 wxPoint *arg2 = 0 ;
13206 wxSize *arg3 = 0 ;
13207 double arg4 ;
13208 wxPoint temp2 ;
13209 wxSize temp3 ;
13210 PyObject * obj0 = 0 ;
13211 PyObject * obj1 = 0 ;
13212 PyObject * obj2 = 0 ;
13213 PyObject * obj3 = 0 ;
13214 char *kwnames[] = {
13215 (char *) "self",(char *) "pt",(char *) "sz",(char *) "radius", NULL
13216 };
13217
13218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRoundedRectanglePointSize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13220 if (SWIG_arg_fail(1)) SWIG_fail;
13221 {
13222 arg2 = &temp2;
13223 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13224 }
13225 {
13226 arg3 = &temp3;
13227 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13228 }
13229 {
13230 arg4 = (double)(SWIG_As_double(obj3));
13231 if (SWIG_arg_fail(4)) SWIG_fail;
13232 }
13233 {
13234 PyThreadState* __tstate = wxPyBeginAllowThreads();
13235 (arg1)->DrawRoundedRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4);
13236
13237 wxPyEndAllowThreads(__tstate);
13238 if (PyErr_Occurred()) SWIG_fail;
13239 }
13240 Py_INCREF(Py_None); resultobj = Py_None;
13241 return resultobj;
13242 fail:
13243 return NULL;
13244 }
13245
13246
13247 static PyObject *_wrap_DC_DrawCircle(PyObject *, PyObject *args, PyObject *kwargs) {
13248 PyObject *resultobj;
13249 wxDC *arg1 = (wxDC *) 0 ;
13250 int arg2 ;
13251 int arg3 ;
13252 int arg4 ;
13253 PyObject * obj0 = 0 ;
13254 PyObject * obj1 = 0 ;
13255 PyObject * obj2 = 0 ;
13256 PyObject * obj3 = 0 ;
13257 char *kwnames[] = {
13258 (char *) "self",(char *) "x",(char *) "y",(char *) "radius", NULL
13259 };
13260
13261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawCircle",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13263 if (SWIG_arg_fail(1)) SWIG_fail;
13264 {
13265 arg2 = (int)(SWIG_As_int(obj1));
13266 if (SWIG_arg_fail(2)) SWIG_fail;
13267 }
13268 {
13269 arg3 = (int)(SWIG_As_int(obj2));
13270 if (SWIG_arg_fail(3)) SWIG_fail;
13271 }
13272 {
13273 arg4 = (int)(SWIG_As_int(obj3));
13274 if (SWIG_arg_fail(4)) SWIG_fail;
13275 }
13276 {
13277 PyThreadState* __tstate = wxPyBeginAllowThreads();
13278 (arg1)->DrawCircle(arg2,arg3,arg4);
13279
13280 wxPyEndAllowThreads(__tstate);
13281 if (PyErr_Occurred()) SWIG_fail;
13282 }
13283 Py_INCREF(Py_None); resultobj = Py_None;
13284 return resultobj;
13285 fail:
13286 return NULL;
13287 }
13288
13289
13290 static PyObject *_wrap_DC_DrawCirclePoint(PyObject *, PyObject *args, PyObject *kwargs) {
13291 PyObject *resultobj;
13292 wxDC *arg1 = (wxDC *) 0 ;
13293 wxPoint *arg2 = 0 ;
13294 int arg3 ;
13295 wxPoint temp2 ;
13296 PyObject * obj0 = 0 ;
13297 PyObject * obj1 = 0 ;
13298 PyObject * obj2 = 0 ;
13299 char *kwnames[] = {
13300 (char *) "self",(char *) "pt",(char *) "radius", NULL
13301 };
13302
13303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawCirclePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13305 if (SWIG_arg_fail(1)) SWIG_fail;
13306 {
13307 arg2 = &temp2;
13308 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13309 }
13310 {
13311 arg3 = (int)(SWIG_As_int(obj2));
13312 if (SWIG_arg_fail(3)) SWIG_fail;
13313 }
13314 {
13315 PyThreadState* __tstate = wxPyBeginAllowThreads();
13316 (arg1)->DrawCircle((wxPoint const &)*arg2,arg3);
13317
13318 wxPyEndAllowThreads(__tstate);
13319 if (PyErr_Occurred()) SWIG_fail;
13320 }
13321 Py_INCREF(Py_None); resultobj = Py_None;
13322 return resultobj;
13323 fail:
13324 return NULL;
13325 }
13326
13327
13328 static PyObject *_wrap_DC_DrawEllipse(PyObject *, PyObject *args, PyObject *kwargs) {
13329 PyObject *resultobj;
13330 wxDC *arg1 = (wxDC *) 0 ;
13331 int arg2 ;
13332 int arg3 ;
13333 int arg4 ;
13334 int arg5 ;
13335 PyObject * obj0 = 0 ;
13336 PyObject * obj1 = 0 ;
13337 PyObject * obj2 = 0 ;
13338 PyObject * obj3 = 0 ;
13339 PyObject * obj4 = 0 ;
13340 char *kwnames[] = {
13341 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13342 };
13343
13344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipse",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13346 if (SWIG_arg_fail(1)) SWIG_fail;
13347 {
13348 arg2 = (int)(SWIG_As_int(obj1));
13349 if (SWIG_arg_fail(2)) SWIG_fail;
13350 }
13351 {
13352 arg3 = (int)(SWIG_As_int(obj2));
13353 if (SWIG_arg_fail(3)) SWIG_fail;
13354 }
13355 {
13356 arg4 = (int)(SWIG_As_int(obj3));
13357 if (SWIG_arg_fail(4)) SWIG_fail;
13358 }
13359 {
13360 arg5 = (int)(SWIG_As_int(obj4));
13361 if (SWIG_arg_fail(5)) SWIG_fail;
13362 }
13363 {
13364 PyThreadState* __tstate = wxPyBeginAllowThreads();
13365 (arg1)->DrawEllipse(arg2,arg3,arg4,arg5);
13366
13367 wxPyEndAllowThreads(__tstate);
13368 if (PyErr_Occurred()) SWIG_fail;
13369 }
13370 Py_INCREF(Py_None); resultobj = Py_None;
13371 return resultobj;
13372 fail:
13373 return NULL;
13374 }
13375
13376
13377 static PyObject *_wrap_DC_DrawEllipseRect(PyObject *, PyObject *args, PyObject *kwargs) {
13378 PyObject *resultobj;
13379 wxDC *arg1 = (wxDC *) 0 ;
13380 wxRect *arg2 = 0 ;
13381 wxRect temp2 ;
13382 PyObject * obj0 = 0 ;
13383 PyObject * obj1 = 0 ;
13384 char *kwnames[] = {
13385 (char *) "self",(char *) "rect", NULL
13386 };
13387
13388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawEllipseRect",kwnames,&obj0,&obj1)) goto fail;
13389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13390 if (SWIG_arg_fail(1)) SWIG_fail;
13391 {
13392 arg2 = &temp2;
13393 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13394 }
13395 {
13396 PyThreadState* __tstate = wxPyBeginAllowThreads();
13397 (arg1)->DrawEllipse((wxRect const &)*arg2);
13398
13399 wxPyEndAllowThreads(__tstate);
13400 if (PyErr_Occurred()) SWIG_fail;
13401 }
13402 Py_INCREF(Py_None); resultobj = Py_None;
13403 return resultobj;
13404 fail:
13405 return NULL;
13406 }
13407
13408
13409 static PyObject *_wrap_DC_DrawEllipsePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13410 PyObject *resultobj;
13411 wxDC *arg1 = (wxDC *) 0 ;
13412 wxPoint *arg2 = 0 ;
13413 wxSize *arg3 = 0 ;
13414 wxPoint temp2 ;
13415 wxSize temp3 ;
13416 PyObject * obj0 = 0 ;
13417 PyObject * obj1 = 0 ;
13418 PyObject * obj2 = 0 ;
13419 char *kwnames[] = {
13420 (char *) "self",(char *) "pt",(char *) "sz", NULL
13421 };
13422
13423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawEllipsePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13425 if (SWIG_arg_fail(1)) SWIG_fail;
13426 {
13427 arg2 = &temp2;
13428 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13429 }
13430 {
13431 arg3 = &temp3;
13432 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13433 }
13434 {
13435 PyThreadState* __tstate = wxPyBeginAllowThreads();
13436 (arg1)->DrawEllipse((wxPoint const &)*arg2,(wxSize const &)*arg3);
13437
13438 wxPyEndAllowThreads(__tstate);
13439 if (PyErr_Occurred()) SWIG_fail;
13440 }
13441 Py_INCREF(Py_None); resultobj = Py_None;
13442 return resultobj;
13443 fail:
13444 return NULL;
13445 }
13446
13447
13448 static PyObject *_wrap_DC_DrawIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13449 PyObject *resultobj;
13450 wxDC *arg1 = (wxDC *) 0 ;
13451 wxIcon *arg2 = 0 ;
13452 int arg3 ;
13453 int arg4 ;
13454 PyObject * obj0 = 0 ;
13455 PyObject * obj1 = 0 ;
13456 PyObject * obj2 = 0 ;
13457 PyObject * obj3 = 0 ;
13458 char *kwnames[] = {
13459 (char *) "self",(char *) "icon",(char *) "x",(char *) "y", NULL
13460 };
13461
13462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13464 if (SWIG_arg_fail(1)) SWIG_fail;
13465 {
13466 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
13467 if (SWIG_arg_fail(2)) SWIG_fail;
13468 if (arg2 == NULL) {
13469 SWIG_null_ref("wxIcon");
13470 }
13471 if (SWIG_arg_fail(2)) SWIG_fail;
13472 }
13473 {
13474 arg3 = (int)(SWIG_As_int(obj2));
13475 if (SWIG_arg_fail(3)) SWIG_fail;
13476 }
13477 {
13478 arg4 = (int)(SWIG_As_int(obj3));
13479 if (SWIG_arg_fail(4)) SWIG_fail;
13480 }
13481 {
13482 PyThreadState* __tstate = wxPyBeginAllowThreads();
13483 (arg1)->DrawIcon((wxIcon const &)*arg2,arg3,arg4);
13484
13485 wxPyEndAllowThreads(__tstate);
13486 if (PyErr_Occurred()) SWIG_fail;
13487 }
13488 Py_INCREF(Py_None); resultobj = Py_None;
13489 return resultobj;
13490 fail:
13491 return NULL;
13492 }
13493
13494
13495 static PyObject *_wrap_DC_DrawIconPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13496 PyObject *resultobj;
13497 wxDC *arg1 = (wxDC *) 0 ;
13498 wxIcon *arg2 = 0 ;
13499 wxPoint *arg3 = 0 ;
13500 wxPoint temp3 ;
13501 PyObject * obj0 = 0 ;
13502 PyObject * obj1 = 0 ;
13503 PyObject * obj2 = 0 ;
13504 char *kwnames[] = {
13505 (char *) "self",(char *) "icon",(char *) "pt", NULL
13506 };
13507
13508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawIconPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13510 if (SWIG_arg_fail(1)) SWIG_fail;
13511 {
13512 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
13513 if (SWIG_arg_fail(2)) SWIG_fail;
13514 if (arg2 == NULL) {
13515 SWIG_null_ref("wxIcon");
13516 }
13517 if (SWIG_arg_fail(2)) SWIG_fail;
13518 }
13519 {
13520 arg3 = &temp3;
13521 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13522 }
13523 {
13524 PyThreadState* __tstate = wxPyBeginAllowThreads();
13525 (arg1)->DrawIcon((wxIcon const &)*arg2,(wxPoint const &)*arg3);
13526
13527 wxPyEndAllowThreads(__tstate);
13528 if (PyErr_Occurred()) SWIG_fail;
13529 }
13530 Py_INCREF(Py_None); resultobj = Py_None;
13531 return resultobj;
13532 fail:
13533 return NULL;
13534 }
13535
13536
13537 static PyObject *_wrap_DC_DrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13538 PyObject *resultobj;
13539 wxDC *arg1 = (wxDC *) 0 ;
13540 wxBitmap *arg2 = 0 ;
13541 int arg3 ;
13542 int arg4 ;
13543 bool arg5 = (bool) false ;
13544 PyObject * obj0 = 0 ;
13545 PyObject * obj1 = 0 ;
13546 PyObject * obj2 = 0 ;
13547 PyObject * obj3 = 0 ;
13548 PyObject * obj4 = 0 ;
13549 char *kwnames[] = {
13550 (char *) "self",(char *) "bmp",(char *) "x",(char *) "y",(char *) "useMask", NULL
13551 };
13552
13553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_DrawBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13555 if (SWIG_arg_fail(1)) SWIG_fail;
13556 {
13557 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
13558 if (SWIG_arg_fail(2)) SWIG_fail;
13559 if (arg2 == NULL) {
13560 SWIG_null_ref("wxBitmap");
13561 }
13562 if (SWIG_arg_fail(2)) SWIG_fail;
13563 }
13564 {
13565 arg3 = (int)(SWIG_As_int(obj2));
13566 if (SWIG_arg_fail(3)) SWIG_fail;
13567 }
13568 {
13569 arg4 = (int)(SWIG_As_int(obj3));
13570 if (SWIG_arg_fail(4)) SWIG_fail;
13571 }
13572 if (obj4) {
13573 {
13574 arg5 = (bool)(SWIG_As_bool(obj4));
13575 if (SWIG_arg_fail(5)) SWIG_fail;
13576 }
13577 }
13578 {
13579 PyThreadState* __tstate = wxPyBeginAllowThreads();
13580 (arg1)->DrawBitmap((wxBitmap const &)*arg2,arg3,arg4,arg5);
13581
13582 wxPyEndAllowThreads(__tstate);
13583 if (PyErr_Occurred()) SWIG_fail;
13584 }
13585 Py_INCREF(Py_None); resultobj = Py_None;
13586 return resultobj;
13587 fail:
13588 return NULL;
13589 }
13590
13591
13592 static PyObject *_wrap_DC_DrawBitmapPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13593 PyObject *resultobj;
13594 wxDC *arg1 = (wxDC *) 0 ;
13595 wxBitmap *arg2 = 0 ;
13596 wxPoint *arg3 = 0 ;
13597 bool arg4 = (bool) false ;
13598 wxPoint temp3 ;
13599 PyObject * obj0 = 0 ;
13600 PyObject * obj1 = 0 ;
13601 PyObject * obj2 = 0 ;
13602 PyObject * obj3 = 0 ;
13603 char *kwnames[] = {
13604 (char *) "self",(char *) "bmp",(char *) "pt",(char *) "useMask", NULL
13605 };
13606
13607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_DrawBitmapPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13609 if (SWIG_arg_fail(1)) SWIG_fail;
13610 {
13611 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
13612 if (SWIG_arg_fail(2)) SWIG_fail;
13613 if (arg2 == NULL) {
13614 SWIG_null_ref("wxBitmap");
13615 }
13616 if (SWIG_arg_fail(2)) SWIG_fail;
13617 }
13618 {
13619 arg3 = &temp3;
13620 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13621 }
13622 if (obj3) {
13623 {
13624 arg4 = (bool)(SWIG_As_bool(obj3));
13625 if (SWIG_arg_fail(4)) SWIG_fail;
13626 }
13627 }
13628 {
13629 PyThreadState* __tstate = wxPyBeginAllowThreads();
13630 (arg1)->DrawBitmap((wxBitmap const &)*arg2,(wxPoint const &)*arg3,arg4);
13631
13632 wxPyEndAllowThreads(__tstate);
13633 if (PyErr_Occurred()) SWIG_fail;
13634 }
13635 Py_INCREF(Py_None); resultobj = Py_None;
13636 return resultobj;
13637 fail:
13638 return NULL;
13639 }
13640
13641
13642 static PyObject *_wrap_DC_DrawText(PyObject *, PyObject *args, PyObject *kwargs) {
13643 PyObject *resultobj;
13644 wxDC *arg1 = (wxDC *) 0 ;
13645 wxString *arg2 = 0 ;
13646 int arg3 ;
13647 int arg4 ;
13648 bool temp2 = false ;
13649 PyObject * obj0 = 0 ;
13650 PyObject * obj1 = 0 ;
13651 PyObject * obj2 = 0 ;
13652 PyObject * obj3 = 0 ;
13653 char *kwnames[] = {
13654 (char *) "self",(char *) "text",(char *) "x",(char *) "y", NULL
13655 };
13656
13657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawText",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13659 if (SWIG_arg_fail(1)) SWIG_fail;
13660 {
13661 arg2 = wxString_in_helper(obj1);
13662 if (arg2 == NULL) SWIG_fail;
13663 temp2 = true;
13664 }
13665 {
13666 arg3 = (int)(SWIG_As_int(obj2));
13667 if (SWIG_arg_fail(3)) SWIG_fail;
13668 }
13669 {
13670 arg4 = (int)(SWIG_As_int(obj3));
13671 if (SWIG_arg_fail(4)) SWIG_fail;
13672 }
13673 {
13674 PyThreadState* __tstate = wxPyBeginAllowThreads();
13675 (arg1)->DrawText((wxString const &)*arg2,arg3,arg4);
13676
13677 wxPyEndAllowThreads(__tstate);
13678 if (PyErr_Occurred()) SWIG_fail;
13679 }
13680 Py_INCREF(Py_None); resultobj = Py_None;
13681 {
13682 if (temp2)
13683 delete arg2;
13684 }
13685 return resultobj;
13686 fail:
13687 {
13688 if (temp2)
13689 delete arg2;
13690 }
13691 return NULL;
13692 }
13693
13694
13695 static PyObject *_wrap_DC_DrawTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13696 PyObject *resultobj;
13697 wxDC *arg1 = (wxDC *) 0 ;
13698 wxString *arg2 = 0 ;
13699 wxPoint *arg3 = 0 ;
13700 bool temp2 = false ;
13701 wxPoint temp3 ;
13702 PyObject * obj0 = 0 ;
13703 PyObject * obj1 = 0 ;
13704 PyObject * obj2 = 0 ;
13705 char *kwnames[] = {
13706 (char *) "self",(char *) "text",(char *) "pt", NULL
13707 };
13708
13709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawTextPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13711 if (SWIG_arg_fail(1)) SWIG_fail;
13712 {
13713 arg2 = wxString_in_helper(obj1);
13714 if (arg2 == NULL) SWIG_fail;
13715 temp2 = true;
13716 }
13717 {
13718 arg3 = &temp3;
13719 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13720 }
13721 {
13722 PyThreadState* __tstate = wxPyBeginAllowThreads();
13723 (arg1)->DrawText((wxString const &)*arg2,(wxPoint const &)*arg3);
13724
13725 wxPyEndAllowThreads(__tstate);
13726 if (PyErr_Occurred()) SWIG_fail;
13727 }
13728 Py_INCREF(Py_None); resultobj = Py_None;
13729 {
13730 if (temp2)
13731 delete arg2;
13732 }
13733 return resultobj;
13734 fail:
13735 {
13736 if (temp2)
13737 delete arg2;
13738 }
13739 return NULL;
13740 }
13741
13742
13743 static PyObject *_wrap_DC_DrawRotatedText(PyObject *, PyObject *args, PyObject *kwargs) {
13744 PyObject *resultobj;
13745 wxDC *arg1 = (wxDC *) 0 ;
13746 wxString *arg2 = 0 ;
13747 int arg3 ;
13748 int arg4 ;
13749 double arg5 ;
13750 bool temp2 = false ;
13751 PyObject * obj0 = 0 ;
13752 PyObject * obj1 = 0 ;
13753 PyObject * obj2 = 0 ;
13754 PyObject * obj3 = 0 ;
13755 PyObject * obj4 = 0 ;
13756 char *kwnames[] = {
13757 (char *) "self",(char *) "text",(char *) "x",(char *) "y",(char *) "angle", NULL
13758 };
13759
13760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRotatedText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13762 if (SWIG_arg_fail(1)) SWIG_fail;
13763 {
13764 arg2 = wxString_in_helper(obj1);
13765 if (arg2 == NULL) SWIG_fail;
13766 temp2 = true;
13767 }
13768 {
13769 arg3 = (int)(SWIG_As_int(obj2));
13770 if (SWIG_arg_fail(3)) SWIG_fail;
13771 }
13772 {
13773 arg4 = (int)(SWIG_As_int(obj3));
13774 if (SWIG_arg_fail(4)) SWIG_fail;
13775 }
13776 {
13777 arg5 = (double)(SWIG_As_double(obj4));
13778 if (SWIG_arg_fail(5)) SWIG_fail;
13779 }
13780 {
13781 PyThreadState* __tstate = wxPyBeginAllowThreads();
13782 (arg1)->DrawRotatedText((wxString const &)*arg2,arg3,arg4,arg5);
13783
13784 wxPyEndAllowThreads(__tstate);
13785 if (PyErr_Occurred()) SWIG_fail;
13786 }
13787 Py_INCREF(Py_None); resultobj = Py_None;
13788 {
13789 if (temp2)
13790 delete arg2;
13791 }
13792 return resultobj;
13793 fail:
13794 {
13795 if (temp2)
13796 delete arg2;
13797 }
13798 return NULL;
13799 }
13800
13801
13802 static PyObject *_wrap_DC_DrawRotatedTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13803 PyObject *resultobj;
13804 wxDC *arg1 = (wxDC *) 0 ;
13805 wxString *arg2 = 0 ;
13806 wxPoint *arg3 = 0 ;
13807 double arg4 ;
13808 bool temp2 = false ;
13809 wxPoint temp3 ;
13810 PyObject * obj0 = 0 ;
13811 PyObject * obj1 = 0 ;
13812 PyObject * obj2 = 0 ;
13813 PyObject * obj3 = 0 ;
13814 char *kwnames[] = {
13815 (char *) "self",(char *) "text",(char *) "pt",(char *) "angle", NULL
13816 };
13817
13818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRotatedTextPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13820 if (SWIG_arg_fail(1)) SWIG_fail;
13821 {
13822 arg2 = wxString_in_helper(obj1);
13823 if (arg2 == NULL) SWIG_fail;
13824 temp2 = true;
13825 }
13826 {
13827 arg3 = &temp3;
13828 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13829 }
13830 {
13831 arg4 = (double)(SWIG_As_double(obj3));
13832 if (SWIG_arg_fail(4)) SWIG_fail;
13833 }
13834 {
13835 PyThreadState* __tstate = wxPyBeginAllowThreads();
13836 (arg1)->DrawRotatedText((wxString const &)*arg2,(wxPoint const &)*arg3,arg4);
13837
13838 wxPyEndAllowThreads(__tstate);
13839 if (PyErr_Occurred()) SWIG_fail;
13840 }
13841 Py_INCREF(Py_None); resultobj = Py_None;
13842 {
13843 if (temp2)
13844 delete arg2;
13845 }
13846 return resultobj;
13847 fail:
13848 {
13849 if (temp2)
13850 delete arg2;
13851 }
13852 return NULL;
13853 }
13854
13855
13856 static PyObject *_wrap_DC_Blit(PyObject *, PyObject *args, PyObject *kwargs) {
13857 PyObject *resultobj;
13858 wxDC *arg1 = (wxDC *) 0 ;
13859 int arg2 ;
13860 int arg3 ;
13861 int arg4 ;
13862 int arg5 ;
13863 wxDC *arg6 = (wxDC *) 0 ;
13864 int arg7 ;
13865 int arg8 ;
13866 int arg9 = (int) wxCOPY ;
13867 bool arg10 = (bool) false ;
13868 int arg11 = (int) -1 ;
13869 int arg12 = (int) -1 ;
13870 bool result;
13871 PyObject * obj0 = 0 ;
13872 PyObject * obj1 = 0 ;
13873 PyObject * obj2 = 0 ;
13874 PyObject * obj3 = 0 ;
13875 PyObject * obj4 = 0 ;
13876 PyObject * obj5 = 0 ;
13877 PyObject * obj6 = 0 ;
13878 PyObject * obj7 = 0 ;
13879 PyObject * obj8 = 0 ;
13880 PyObject * obj9 = 0 ;
13881 PyObject * obj10 = 0 ;
13882 PyObject * obj11 = 0 ;
13883 char *kwnames[] = {
13884 (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
13885 };
13886
13887 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;
13888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13889 if (SWIG_arg_fail(1)) SWIG_fail;
13890 {
13891 arg2 = (int)(SWIG_As_int(obj1));
13892 if (SWIG_arg_fail(2)) SWIG_fail;
13893 }
13894 {
13895 arg3 = (int)(SWIG_As_int(obj2));
13896 if (SWIG_arg_fail(3)) SWIG_fail;
13897 }
13898 {
13899 arg4 = (int)(SWIG_As_int(obj3));
13900 if (SWIG_arg_fail(4)) SWIG_fail;
13901 }
13902 {
13903 arg5 = (int)(SWIG_As_int(obj4));
13904 if (SWIG_arg_fail(5)) SWIG_fail;
13905 }
13906 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13907 if (SWIG_arg_fail(6)) SWIG_fail;
13908 {
13909 arg7 = (int)(SWIG_As_int(obj6));
13910 if (SWIG_arg_fail(7)) SWIG_fail;
13911 }
13912 {
13913 arg8 = (int)(SWIG_As_int(obj7));
13914 if (SWIG_arg_fail(8)) SWIG_fail;
13915 }
13916 if (obj8) {
13917 {
13918 arg9 = (int)(SWIG_As_int(obj8));
13919 if (SWIG_arg_fail(9)) SWIG_fail;
13920 }
13921 }
13922 if (obj9) {
13923 {
13924 arg10 = (bool)(SWIG_As_bool(obj9));
13925 if (SWIG_arg_fail(10)) SWIG_fail;
13926 }
13927 }
13928 if (obj10) {
13929 {
13930 arg11 = (int)(SWIG_As_int(obj10));
13931 if (SWIG_arg_fail(11)) SWIG_fail;
13932 }
13933 }
13934 if (obj11) {
13935 {
13936 arg12 = (int)(SWIG_As_int(obj11));
13937 if (SWIG_arg_fail(12)) SWIG_fail;
13938 }
13939 }
13940 {
13941 PyThreadState* __tstate = wxPyBeginAllowThreads();
13942 result = (bool)(arg1)->Blit(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
13943
13944 wxPyEndAllowThreads(__tstate);
13945 if (PyErr_Occurred()) SWIG_fail;
13946 }
13947 {
13948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13949 }
13950 return resultobj;
13951 fail:
13952 return NULL;
13953 }
13954
13955
13956 static PyObject *_wrap_DC_BlitPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13957 PyObject *resultobj;
13958 wxDC *arg1 = (wxDC *) 0 ;
13959 wxPoint *arg2 = 0 ;
13960 wxSize *arg3 = 0 ;
13961 wxDC *arg4 = (wxDC *) 0 ;
13962 wxPoint *arg5 = 0 ;
13963 int arg6 = (int) wxCOPY ;
13964 bool arg7 = (bool) false ;
13965 wxPoint const &arg8_defvalue = wxDefaultPosition ;
13966 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
13967 bool result;
13968 wxPoint temp2 ;
13969 wxSize temp3 ;
13970 wxPoint temp5 ;
13971 wxPoint temp8 ;
13972 PyObject * obj0 = 0 ;
13973 PyObject * obj1 = 0 ;
13974 PyObject * obj2 = 0 ;
13975 PyObject * obj3 = 0 ;
13976 PyObject * obj4 = 0 ;
13977 PyObject * obj5 = 0 ;
13978 PyObject * obj6 = 0 ;
13979 PyObject * obj7 = 0 ;
13980 char *kwnames[] = {
13981 (char *) "self",(char *) "destPt",(char *) "sz",(char *) "source",(char *) "srcPt",(char *) "rop",(char *) "useMask",(char *) "srcPtMask", NULL
13982 };
13983
13984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:DC_BlitPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
13985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13986 if (SWIG_arg_fail(1)) SWIG_fail;
13987 {
13988 arg2 = &temp2;
13989 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13990 }
13991 {
13992 arg3 = &temp3;
13993 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13994 }
13995 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13996 if (SWIG_arg_fail(4)) SWIG_fail;
13997 {
13998 arg5 = &temp5;
13999 if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
14000 }
14001 if (obj5) {
14002 {
14003 arg6 = (int)(SWIG_As_int(obj5));
14004 if (SWIG_arg_fail(6)) SWIG_fail;
14005 }
14006 }
14007 if (obj6) {
14008 {
14009 arg7 = (bool)(SWIG_As_bool(obj6));
14010 if (SWIG_arg_fail(7)) SWIG_fail;
14011 }
14012 }
14013 if (obj7) {
14014 {
14015 arg8 = &temp8;
14016 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
14017 }
14018 }
14019 {
14020 PyThreadState* __tstate = wxPyBeginAllowThreads();
14021 result = (bool)(arg1)->Blit((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,(wxPoint const &)*arg5,arg6,arg7,(wxPoint const &)*arg8);
14022
14023 wxPyEndAllowThreads(__tstate);
14024 if (PyErr_Occurred()) SWIG_fail;
14025 }
14026 {
14027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14028 }
14029 return resultobj;
14030 fail:
14031 return NULL;
14032 }
14033
14034
14035 static PyObject *_wrap_DC_SetClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14036 PyObject *resultobj;
14037 wxDC *arg1 = (wxDC *) 0 ;
14038 int arg2 ;
14039 int arg3 ;
14040 int arg4 ;
14041 int arg5 ;
14042 PyObject * obj0 = 0 ;
14043 PyObject * obj1 = 0 ;
14044 PyObject * obj2 = 0 ;
14045 PyObject * obj3 = 0 ;
14046 PyObject * obj4 = 0 ;
14047 char *kwnames[] = {
14048 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
14049 };
14050
14051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_SetClippingRegion",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14053 if (SWIG_arg_fail(1)) SWIG_fail;
14054 {
14055 arg2 = (int)(SWIG_As_int(obj1));
14056 if (SWIG_arg_fail(2)) SWIG_fail;
14057 }
14058 {
14059 arg3 = (int)(SWIG_As_int(obj2));
14060 if (SWIG_arg_fail(3)) SWIG_fail;
14061 }
14062 {
14063 arg4 = (int)(SWIG_As_int(obj3));
14064 if (SWIG_arg_fail(4)) SWIG_fail;
14065 }
14066 {
14067 arg5 = (int)(SWIG_As_int(obj4));
14068 if (SWIG_arg_fail(5)) SWIG_fail;
14069 }
14070 {
14071 PyThreadState* __tstate = wxPyBeginAllowThreads();
14072 (arg1)->SetClippingRegion(arg2,arg3,arg4,arg5);
14073
14074 wxPyEndAllowThreads(__tstate);
14075 if (PyErr_Occurred()) SWIG_fail;
14076 }
14077 Py_INCREF(Py_None); resultobj = Py_None;
14078 return resultobj;
14079 fail:
14080 return NULL;
14081 }
14082
14083
14084 static PyObject *_wrap_DC_SetClippingRegionPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14085 PyObject *resultobj;
14086 wxDC *arg1 = (wxDC *) 0 ;
14087 wxPoint *arg2 = 0 ;
14088 wxSize *arg3 = 0 ;
14089 wxPoint temp2 ;
14090 wxSize temp3 ;
14091 PyObject * obj0 = 0 ;
14092 PyObject * obj1 = 0 ;
14093 PyObject * obj2 = 0 ;
14094 char *kwnames[] = {
14095 (char *) "self",(char *) "pt",(char *) "sz", NULL
14096 };
14097
14098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetClippingRegionPointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14100 if (SWIG_arg_fail(1)) SWIG_fail;
14101 {
14102 arg2 = &temp2;
14103 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14104 }
14105 {
14106 arg3 = &temp3;
14107 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14108 }
14109 {
14110 PyThreadState* __tstate = wxPyBeginAllowThreads();
14111 (arg1)->SetClippingRegion((wxPoint const &)*arg2,(wxSize const &)*arg3);
14112
14113 wxPyEndAllowThreads(__tstate);
14114 if (PyErr_Occurred()) SWIG_fail;
14115 }
14116 Py_INCREF(Py_None); resultobj = Py_None;
14117 return resultobj;
14118 fail:
14119 return NULL;
14120 }
14121
14122
14123 static PyObject *_wrap_DC_SetClippingRegionAsRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14124 PyObject *resultobj;
14125 wxDC *arg1 = (wxDC *) 0 ;
14126 wxRegion *arg2 = 0 ;
14127 PyObject * obj0 = 0 ;
14128 PyObject * obj1 = 0 ;
14129 char *kwnames[] = {
14130 (char *) "self",(char *) "region", NULL
14131 };
14132
14133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRegionAsRegion",kwnames,&obj0,&obj1)) goto fail;
14134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14135 if (SWIG_arg_fail(1)) SWIG_fail;
14136 {
14137 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
14138 if (SWIG_arg_fail(2)) SWIG_fail;
14139 if (arg2 == NULL) {
14140 SWIG_null_ref("wxRegion");
14141 }
14142 if (SWIG_arg_fail(2)) SWIG_fail;
14143 }
14144 {
14145 PyThreadState* __tstate = wxPyBeginAllowThreads();
14146 (arg1)->SetClippingRegion((wxRegion const &)*arg2);
14147
14148 wxPyEndAllowThreads(__tstate);
14149 if (PyErr_Occurred()) SWIG_fail;
14150 }
14151 Py_INCREF(Py_None); resultobj = Py_None;
14152 return resultobj;
14153 fail:
14154 return NULL;
14155 }
14156
14157
14158 static PyObject *_wrap_DC_SetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
14159 PyObject *resultobj;
14160 wxDC *arg1 = (wxDC *) 0 ;
14161 wxRect *arg2 = 0 ;
14162 wxRect temp2 ;
14163 PyObject * obj0 = 0 ;
14164 PyObject * obj1 = 0 ;
14165 char *kwnames[] = {
14166 (char *) "self",(char *) "rect", NULL
14167 };
14168
14169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRect",kwnames,&obj0,&obj1)) goto fail;
14170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14171 if (SWIG_arg_fail(1)) SWIG_fail;
14172 {
14173 arg2 = &temp2;
14174 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14175 }
14176 {
14177 PyThreadState* __tstate = wxPyBeginAllowThreads();
14178 (arg1)->SetClippingRegion((wxRect const &)*arg2);
14179
14180 wxPyEndAllowThreads(__tstate);
14181 if (PyErr_Occurred()) SWIG_fail;
14182 }
14183 Py_INCREF(Py_None); resultobj = Py_None;
14184 return resultobj;
14185 fail:
14186 return NULL;
14187 }
14188
14189
14190 static PyObject *_wrap_DC_DrawLines(PyObject *, PyObject *args, PyObject *kwargs) {
14191 PyObject *resultobj;
14192 wxDC *arg1 = (wxDC *) 0 ;
14193 int arg2 ;
14194 wxPoint *arg3 = (wxPoint *) 0 ;
14195 int arg4 = (int) 0 ;
14196 int arg5 = (int) 0 ;
14197 PyObject * obj0 = 0 ;
14198 PyObject * obj1 = 0 ;
14199 PyObject * obj2 = 0 ;
14200 PyObject * obj3 = 0 ;
14201 char *kwnames[] = {
14202 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset", NULL
14203 };
14204
14205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DC_DrawLines",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14207 if (SWIG_arg_fail(1)) SWIG_fail;
14208 {
14209 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14210 if (arg3 == NULL) SWIG_fail;
14211 }
14212 if (obj2) {
14213 {
14214 arg4 = (int)(SWIG_As_int(obj2));
14215 if (SWIG_arg_fail(4)) SWIG_fail;
14216 }
14217 }
14218 if (obj3) {
14219 {
14220 arg5 = (int)(SWIG_As_int(obj3));
14221 if (SWIG_arg_fail(5)) SWIG_fail;
14222 }
14223 }
14224 {
14225 PyThreadState* __tstate = wxPyBeginAllowThreads();
14226 (arg1)->DrawLines(arg2,arg3,arg4,arg5);
14227
14228 wxPyEndAllowThreads(__tstate);
14229 if (PyErr_Occurred()) SWIG_fail;
14230 }
14231 Py_INCREF(Py_None); resultobj = Py_None;
14232 {
14233 if (arg3) delete [] arg3;
14234 }
14235 return resultobj;
14236 fail:
14237 {
14238 if (arg3) delete [] arg3;
14239 }
14240 return NULL;
14241 }
14242
14243
14244 static PyObject *_wrap_DC_DrawPolygon(PyObject *, PyObject *args, PyObject *kwargs) {
14245 PyObject *resultobj;
14246 wxDC *arg1 = (wxDC *) 0 ;
14247 int arg2 ;
14248 wxPoint *arg3 = (wxPoint *) 0 ;
14249 int arg4 = (int) 0 ;
14250 int arg5 = (int) 0 ;
14251 int arg6 = (int) wxODDEVEN_RULE ;
14252 PyObject * obj0 = 0 ;
14253 PyObject * obj1 = 0 ;
14254 PyObject * obj2 = 0 ;
14255 PyObject * obj3 = 0 ;
14256 PyObject * obj4 = 0 ;
14257 char *kwnames[] = {
14258 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset",(char *) "fillStyle", NULL
14259 };
14260
14261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DC_DrawPolygon",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14263 if (SWIG_arg_fail(1)) SWIG_fail;
14264 {
14265 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14266 if (arg3 == NULL) SWIG_fail;
14267 }
14268 if (obj2) {
14269 {
14270 arg4 = (int)(SWIG_As_int(obj2));
14271 if (SWIG_arg_fail(4)) SWIG_fail;
14272 }
14273 }
14274 if (obj3) {
14275 {
14276 arg5 = (int)(SWIG_As_int(obj3));
14277 if (SWIG_arg_fail(5)) SWIG_fail;
14278 }
14279 }
14280 if (obj4) {
14281 {
14282 arg6 = (int)(SWIG_As_int(obj4));
14283 if (SWIG_arg_fail(6)) SWIG_fail;
14284 }
14285 }
14286 {
14287 PyThreadState* __tstate = wxPyBeginAllowThreads();
14288 (arg1)->DrawPolygon(arg2,arg3,arg4,arg5,arg6);
14289
14290 wxPyEndAllowThreads(__tstate);
14291 if (PyErr_Occurred()) SWIG_fail;
14292 }
14293 Py_INCREF(Py_None); resultobj = Py_None;
14294 {
14295 if (arg3) delete [] arg3;
14296 }
14297 return resultobj;
14298 fail:
14299 {
14300 if (arg3) delete [] arg3;
14301 }
14302 return NULL;
14303 }
14304
14305
14306 static PyObject *_wrap_DC_DrawLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14307 PyObject *resultobj;
14308 wxDC *arg1 = (wxDC *) 0 ;
14309 wxString *arg2 = 0 ;
14310 wxRect *arg3 = 0 ;
14311 int arg4 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14312 int arg5 = (int) -1 ;
14313 bool temp2 = false ;
14314 wxRect temp3 ;
14315 PyObject * obj0 = 0 ;
14316 PyObject * obj1 = 0 ;
14317 PyObject * obj2 = 0 ;
14318 PyObject * obj3 = 0 ;
14319 PyObject * obj4 = 0 ;
14320 char *kwnames[] = {
14321 (char *) "self",(char *) "text",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
14322 };
14323
14324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:DC_DrawLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14326 if (SWIG_arg_fail(1)) SWIG_fail;
14327 {
14328 arg2 = wxString_in_helper(obj1);
14329 if (arg2 == NULL) SWIG_fail;
14330 temp2 = true;
14331 }
14332 {
14333 arg3 = &temp3;
14334 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
14335 }
14336 if (obj3) {
14337 {
14338 arg4 = (int)(SWIG_As_int(obj3));
14339 if (SWIG_arg_fail(4)) SWIG_fail;
14340 }
14341 }
14342 if (obj4) {
14343 {
14344 arg5 = (int)(SWIG_As_int(obj4));
14345 if (SWIG_arg_fail(5)) SWIG_fail;
14346 }
14347 }
14348 {
14349 PyThreadState* __tstate = wxPyBeginAllowThreads();
14350 (arg1)->DrawLabel((wxString const &)*arg2,(wxRect const &)*arg3,arg4,arg5);
14351
14352 wxPyEndAllowThreads(__tstate);
14353 if (PyErr_Occurred()) SWIG_fail;
14354 }
14355 Py_INCREF(Py_None); resultobj = Py_None;
14356 {
14357 if (temp2)
14358 delete arg2;
14359 }
14360 return resultobj;
14361 fail:
14362 {
14363 if (temp2)
14364 delete arg2;
14365 }
14366 return NULL;
14367 }
14368
14369
14370 static PyObject *_wrap_DC_DrawImageLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14371 PyObject *resultobj;
14372 wxDC *arg1 = (wxDC *) 0 ;
14373 wxString *arg2 = 0 ;
14374 wxBitmap *arg3 = 0 ;
14375 wxRect *arg4 = 0 ;
14376 int arg5 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14377 int arg6 = (int) -1 ;
14378 wxRect result;
14379 bool temp2 = false ;
14380 wxRect temp4 ;
14381 PyObject * obj0 = 0 ;
14382 PyObject * obj1 = 0 ;
14383 PyObject * obj2 = 0 ;
14384 PyObject * obj3 = 0 ;
14385 PyObject * obj4 = 0 ;
14386 PyObject * obj5 = 0 ;
14387 char *kwnames[] = {
14388 (char *) "self",(char *) "text",(char *) "image",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
14389 };
14390
14391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:DC_DrawImageLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
14392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14393 if (SWIG_arg_fail(1)) SWIG_fail;
14394 {
14395 arg2 = wxString_in_helper(obj1);
14396 if (arg2 == NULL) SWIG_fail;
14397 temp2 = true;
14398 }
14399 {
14400 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
14401 if (SWIG_arg_fail(3)) SWIG_fail;
14402 if (arg3 == NULL) {
14403 SWIG_null_ref("wxBitmap");
14404 }
14405 if (SWIG_arg_fail(3)) SWIG_fail;
14406 }
14407 {
14408 arg4 = &temp4;
14409 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
14410 }
14411 if (obj4) {
14412 {
14413 arg5 = (int)(SWIG_As_int(obj4));
14414 if (SWIG_arg_fail(5)) SWIG_fail;
14415 }
14416 }
14417 if (obj5) {
14418 {
14419 arg6 = (int)(SWIG_As_int(obj5));
14420 if (SWIG_arg_fail(6)) SWIG_fail;
14421 }
14422 }
14423 {
14424 PyThreadState* __tstate = wxPyBeginAllowThreads();
14425 result = wxDC_DrawImageLabel(arg1,(wxString const &)*arg2,(wxBitmap const &)*arg3,(wxRect const &)*arg4,arg5,arg6);
14426
14427 wxPyEndAllowThreads(__tstate);
14428 if (PyErr_Occurred()) SWIG_fail;
14429 }
14430 {
14431 wxRect * resultptr;
14432 resultptr = new wxRect((wxRect &)(result));
14433 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
14434 }
14435 {
14436 if (temp2)
14437 delete arg2;
14438 }
14439 return resultobj;
14440 fail:
14441 {
14442 if (temp2)
14443 delete arg2;
14444 }
14445 return NULL;
14446 }
14447
14448
14449 static PyObject *_wrap_DC_DrawSpline(PyObject *, PyObject *args, PyObject *kwargs) {
14450 PyObject *resultobj;
14451 wxDC *arg1 = (wxDC *) 0 ;
14452 int arg2 ;
14453 wxPoint *arg3 = (wxPoint *) 0 ;
14454 PyObject * obj0 = 0 ;
14455 PyObject * obj1 = 0 ;
14456 char *kwnames[] = {
14457 (char *) "self",(char *) "points", NULL
14458 };
14459
14460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawSpline",kwnames,&obj0,&obj1)) goto fail;
14461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14462 if (SWIG_arg_fail(1)) SWIG_fail;
14463 {
14464 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14465 if (arg3 == NULL) SWIG_fail;
14466 }
14467 {
14468 PyThreadState* __tstate = wxPyBeginAllowThreads();
14469 (arg1)->DrawSpline(arg2,arg3);
14470
14471 wxPyEndAllowThreads(__tstate);
14472 if (PyErr_Occurred()) SWIG_fail;
14473 }
14474 Py_INCREF(Py_None); resultobj = Py_None;
14475 {
14476 if (arg3) delete [] arg3;
14477 }
14478 return resultobj;
14479 fail:
14480 {
14481 if (arg3) delete [] arg3;
14482 }
14483 return NULL;
14484 }
14485
14486
14487 static PyObject *_wrap_DC_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
14488 PyObject *resultobj;
14489 wxDC *arg1 = (wxDC *) 0 ;
14490 PyObject * obj0 = 0 ;
14491 char *kwnames[] = {
14492 (char *) "self", NULL
14493 };
14494
14495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Clear",kwnames,&obj0)) goto fail;
14496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14497 if (SWIG_arg_fail(1)) SWIG_fail;
14498 {
14499 PyThreadState* __tstate = wxPyBeginAllowThreads();
14500 (arg1)->Clear();
14501
14502 wxPyEndAllowThreads(__tstate);
14503 if (PyErr_Occurred()) SWIG_fail;
14504 }
14505 Py_INCREF(Py_None); resultobj = Py_None;
14506 return resultobj;
14507 fail:
14508 return NULL;
14509 }
14510
14511
14512 static PyObject *_wrap_DC_StartDoc(PyObject *, PyObject *args, PyObject *kwargs) {
14513 PyObject *resultobj;
14514 wxDC *arg1 = (wxDC *) 0 ;
14515 wxString *arg2 = 0 ;
14516 bool result;
14517 bool temp2 = false ;
14518 PyObject * obj0 = 0 ;
14519 PyObject * obj1 = 0 ;
14520 char *kwnames[] = {
14521 (char *) "self",(char *) "message", NULL
14522 };
14523
14524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_StartDoc",kwnames,&obj0,&obj1)) goto fail;
14525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14526 if (SWIG_arg_fail(1)) SWIG_fail;
14527 {
14528 arg2 = wxString_in_helper(obj1);
14529 if (arg2 == NULL) SWIG_fail;
14530 temp2 = true;
14531 }
14532 {
14533 PyThreadState* __tstate = wxPyBeginAllowThreads();
14534 result = (bool)(arg1)->StartDoc((wxString const &)*arg2);
14535
14536 wxPyEndAllowThreads(__tstate);
14537 if (PyErr_Occurred()) SWIG_fail;
14538 }
14539 {
14540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14541 }
14542 {
14543 if (temp2)
14544 delete arg2;
14545 }
14546 return resultobj;
14547 fail:
14548 {
14549 if (temp2)
14550 delete arg2;
14551 }
14552 return NULL;
14553 }
14554
14555
14556 static PyObject *_wrap_DC_EndDoc(PyObject *, PyObject *args, PyObject *kwargs) {
14557 PyObject *resultobj;
14558 wxDC *arg1 = (wxDC *) 0 ;
14559 PyObject * obj0 = 0 ;
14560 char *kwnames[] = {
14561 (char *) "self", NULL
14562 };
14563
14564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDoc",kwnames,&obj0)) goto fail;
14565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14566 if (SWIG_arg_fail(1)) SWIG_fail;
14567 {
14568 PyThreadState* __tstate = wxPyBeginAllowThreads();
14569 (arg1)->EndDoc();
14570
14571 wxPyEndAllowThreads(__tstate);
14572 if (PyErr_Occurred()) SWIG_fail;
14573 }
14574 Py_INCREF(Py_None); resultobj = Py_None;
14575 return resultobj;
14576 fail:
14577 return NULL;
14578 }
14579
14580
14581 static PyObject *_wrap_DC_StartPage(PyObject *, PyObject *args, PyObject *kwargs) {
14582 PyObject *resultobj;
14583 wxDC *arg1 = (wxDC *) 0 ;
14584 PyObject * obj0 = 0 ;
14585 char *kwnames[] = {
14586 (char *) "self", NULL
14587 };
14588
14589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_StartPage",kwnames,&obj0)) goto fail;
14590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14591 if (SWIG_arg_fail(1)) SWIG_fail;
14592 {
14593 PyThreadState* __tstate = wxPyBeginAllowThreads();
14594 (arg1)->StartPage();
14595
14596 wxPyEndAllowThreads(__tstate);
14597 if (PyErr_Occurred()) SWIG_fail;
14598 }
14599 Py_INCREF(Py_None); resultobj = Py_None;
14600 return resultobj;
14601 fail:
14602 return NULL;
14603 }
14604
14605
14606 static PyObject *_wrap_DC_EndPage(PyObject *, PyObject *args, PyObject *kwargs) {
14607 PyObject *resultobj;
14608 wxDC *arg1 = (wxDC *) 0 ;
14609 PyObject * obj0 = 0 ;
14610 char *kwnames[] = {
14611 (char *) "self", NULL
14612 };
14613
14614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndPage",kwnames,&obj0)) goto fail;
14615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14616 if (SWIG_arg_fail(1)) SWIG_fail;
14617 {
14618 PyThreadState* __tstate = wxPyBeginAllowThreads();
14619 (arg1)->EndPage();
14620
14621 wxPyEndAllowThreads(__tstate);
14622 if (PyErr_Occurred()) SWIG_fail;
14623 }
14624 Py_INCREF(Py_None); resultobj = Py_None;
14625 return resultobj;
14626 fail:
14627 return NULL;
14628 }
14629
14630
14631 static PyObject *_wrap_DC_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
14632 PyObject *resultobj;
14633 wxDC *arg1 = (wxDC *) 0 ;
14634 wxFont *arg2 = 0 ;
14635 PyObject * obj0 = 0 ;
14636 PyObject * obj1 = 0 ;
14637 char *kwnames[] = {
14638 (char *) "self",(char *) "font", NULL
14639 };
14640
14641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetFont",kwnames,&obj0,&obj1)) goto fail;
14642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14643 if (SWIG_arg_fail(1)) SWIG_fail;
14644 {
14645 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
14646 if (SWIG_arg_fail(2)) SWIG_fail;
14647 if (arg2 == NULL) {
14648 SWIG_null_ref("wxFont");
14649 }
14650 if (SWIG_arg_fail(2)) SWIG_fail;
14651 }
14652 {
14653 PyThreadState* __tstate = wxPyBeginAllowThreads();
14654 (arg1)->SetFont((wxFont const &)*arg2);
14655
14656 wxPyEndAllowThreads(__tstate);
14657 if (PyErr_Occurred()) SWIG_fail;
14658 }
14659 Py_INCREF(Py_None); resultobj = Py_None;
14660 return resultobj;
14661 fail:
14662 return NULL;
14663 }
14664
14665
14666 static PyObject *_wrap_DC_SetPen(PyObject *, PyObject *args, PyObject *kwargs) {
14667 PyObject *resultobj;
14668 wxDC *arg1 = (wxDC *) 0 ;
14669 wxPen *arg2 = 0 ;
14670 PyObject * obj0 = 0 ;
14671 PyObject * obj1 = 0 ;
14672 char *kwnames[] = {
14673 (char *) "self",(char *) "pen", NULL
14674 };
14675
14676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPen",kwnames,&obj0,&obj1)) goto fail;
14677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14678 if (SWIG_arg_fail(1)) SWIG_fail;
14679 {
14680 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
14681 if (SWIG_arg_fail(2)) SWIG_fail;
14682 if (arg2 == NULL) {
14683 SWIG_null_ref("wxPen");
14684 }
14685 if (SWIG_arg_fail(2)) SWIG_fail;
14686 }
14687 {
14688 PyThreadState* __tstate = wxPyBeginAllowThreads();
14689 (arg1)->SetPen((wxPen const &)*arg2);
14690
14691 wxPyEndAllowThreads(__tstate);
14692 if (PyErr_Occurred()) SWIG_fail;
14693 }
14694 Py_INCREF(Py_None); resultobj = Py_None;
14695 return resultobj;
14696 fail:
14697 return NULL;
14698 }
14699
14700
14701 static PyObject *_wrap_DC_SetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
14702 PyObject *resultobj;
14703 wxDC *arg1 = (wxDC *) 0 ;
14704 wxBrush *arg2 = 0 ;
14705 PyObject * obj0 = 0 ;
14706 PyObject * obj1 = 0 ;
14707 char *kwnames[] = {
14708 (char *) "self",(char *) "brush", NULL
14709 };
14710
14711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBrush",kwnames,&obj0,&obj1)) goto fail;
14712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14713 if (SWIG_arg_fail(1)) SWIG_fail;
14714 {
14715 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
14716 if (SWIG_arg_fail(2)) SWIG_fail;
14717 if (arg2 == NULL) {
14718 SWIG_null_ref("wxBrush");
14719 }
14720 if (SWIG_arg_fail(2)) SWIG_fail;
14721 }
14722 {
14723 PyThreadState* __tstate = wxPyBeginAllowThreads();
14724 (arg1)->SetBrush((wxBrush const &)*arg2);
14725
14726 wxPyEndAllowThreads(__tstate);
14727 if (PyErr_Occurred()) SWIG_fail;
14728 }
14729 Py_INCREF(Py_None); resultobj = Py_None;
14730 return resultobj;
14731 fail:
14732 return NULL;
14733 }
14734
14735
14736 static PyObject *_wrap_DC_SetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
14737 PyObject *resultobj;
14738 wxDC *arg1 = (wxDC *) 0 ;
14739 wxBrush *arg2 = 0 ;
14740 PyObject * obj0 = 0 ;
14741 PyObject * obj1 = 0 ;
14742 char *kwnames[] = {
14743 (char *) "self",(char *) "brush", NULL
14744 };
14745
14746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackground",kwnames,&obj0,&obj1)) goto fail;
14747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14748 if (SWIG_arg_fail(1)) SWIG_fail;
14749 {
14750 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
14751 if (SWIG_arg_fail(2)) SWIG_fail;
14752 if (arg2 == NULL) {
14753 SWIG_null_ref("wxBrush");
14754 }
14755 if (SWIG_arg_fail(2)) SWIG_fail;
14756 }
14757 {
14758 PyThreadState* __tstate = wxPyBeginAllowThreads();
14759 (arg1)->SetBackground((wxBrush const &)*arg2);
14760
14761 wxPyEndAllowThreads(__tstate);
14762 if (PyErr_Occurred()) SWIG_fail;
14763 }
14764 Py_INCREF(Py_None); resultobj = Py_None;
14765 return resultobj;
14766 fail:
14767 return NULL;
14768 }
14769
14770
14771 static PyObject *_wrap_DC_SetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
14772 PyObject *resultobj;
14773 wxDC *arg1 = (wxDC *) 0 ;
14774 int arg2 ;
14775 PyObject * obj0 = 0 ;
14776 PyObject * obj1 = 0 ;
14777 char *kwnames[] = {
14778 (char *) "self",(char *) "mode", NULL
14779 };
14780
14781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackgroundMode",kwnames,&obj0,&obj1)) goto fail;
14782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14783 if (SWIG_arg_fail(1)) SWIG_fail;
14784 {
14785 arg2 = (int)(SWIG_As_int(obj1));
14786 if (SWIG_arg_fail(2)) SWIG_fail;
14787 }
14788 {
14789 PyThreadState* __tstate = wxPyBeginAllowThreads();
14790 (arg1)->SetBackgroundMode(arg2);
14791
14792 wxPyEndAllowThreads(__tstate);
14793 if (PyErr_Occurred()) SWIG_fail;
14794 }
14795 Py_INCREF(Py_None); resultobj = Py_None;
14796 return resultobj;
14797 fail:
14798 return NULL;
14799 }
14800
14801
14802 static PyObject *_wrap_DC_SetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
14803 PyObject *resultobj;
14804 wxDC *arg1 = (wxDC *) 0 ;
14805 wxPalette *arg2 = 0 ;
14806 PyObject * obj0 = 0 ;
14807 PyObject * obj1 = 0 ;
14808 char *kwnames[] = {
14809 (char *) "self",(char *) "palette", NULL
14810 };
14811
14812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPalette",kwnames,&obj0,&obj1)) goto fail;
14813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14814 if (SWIG_arg_fail(1)) SWIG_fail;
14815 {
14816 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
14817 if (SWIG_arg_fail(2)) SWIG_fail;
14818 if (arg2 == NULL) {
14819 SWIG_null_ref("wxPalette");
14820 }
14821 if (SWIG_arg_fail(2)) SWIG_fail;
14822 }
14823 {
14824 PyThreadState* __tstate = wxPyBeginAllowThreads();
14825 (arg1)->SetPalette((wxPalette const &)*arg2);
14826
14827 wxPyEndAllowThreads(__tstate);
14828 if (PyErr_Occurred()) SWIG_fail;
14829 }
14830 Py_INCREF(Py_None); resultobj = Py_None;
14831 return resultobj;
14832 fail:
14833 return NULL;
14834 }
14835
14836
14837 static PyObject *_wrap_DC_DestroyClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14838 PyObject *resultobj;
14839 wxDC *arg1 = (wxDC *) 0 ;
14840 PyObject * obj0 = 0 ;
14841 char *kwnames[] = {
14842 (char *) "self", NULL
14843 };
14844
14845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_DestroyClippingRegion",kwnames,&obj0)) goto fail;
14846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14847 if (SWIG_arg_fail(1)) SWIG_fail;
14848 {
14849 PyThreadState* __tstate = wxPyBeginAllowThreads();
14850 (arg1)->DestroyClippingRegion();
14851
14852 wxPyEndAllowThreads(__tstate);
14853 if (PyErr_Occurred()) SWIG_fail;
14854 }
14855 Py_INCREF(Py_None); resultobj = Py_None;
14856 return resultobj;
14857 fail:
14858 return NULL;
14859 }
14860
14861
14862 static PyObject *_wrap_DC_GetClippingBox(PyObject *, PyObject *args, PyObject *kwargs) {
14863 PyObject *resultobj;
14864 wxDC *arg1 = (wxDC *) 0 ;
14865 int *arg2 = (int *) 0 ;
14866 int *arg3 = (int *) 0 ;
14867 int *arg4 = (int *) 0 ;
14868 int *arg5 = (int *) 0 ;
14869 int temp2 ;
14870 int res2 = 0 ;
14871 int temp3 ;
14872 int res3 = 0 ;
14873 int temp4 ;
14874 int res4 = 0 ;
14875 int temp5 ;
14876 int res5 = 0 ;
14877 PyObject * obj0 = 0 ;
14878 char *kwnames[] = {
14879 (char *) "self", NULL
14880 };
14881
14882 arg2 = &temp2; res2 = SWIG_NEWOBJ;
14883 arg3 = &temp3; res3 = SWIG_NEWOBJ;
14884 arg4 = &temp4; res4 = SWIG_NEWOBJ;
14885 arg5 = &temp5; res5 = SWIG_NEWOBJ;
14886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingBox",kwnames,&obj0)) goto fail;
14887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14888 if (SWIG_arg_fail(1)) SWIG_fail;
14889 {
14890 PyThreadState* __tstate = wxPyBeginAllowThreads();
14891 ((wxDC const *)arg1)->GetClippingBox(arg2,arg3,arg4,arg5);
14892
14893 wxPyEndAllowThreads(__tstate);
14894 if (PyErr_Occurred()) SWIG_fail;
14895 }
14896 Py_INCREF(Py_None); resultobj = Py_None;
14897 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
14898 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
14899 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
14900 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
14901 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
14902 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
14903 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
14904 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
14905 return resultobj;
14906 fail:
14907 return NULL;
14908 }
14909
14910
14911 static PyObject *_wrap_DC_GetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
14912 PyObject *resultobj;
14913 wxDC *arg1 = (wxDC *) 0 ;
14914 wxRect result;
14915 PyObject * obj0 = 0 ;
14916 char *kwnames[] = {
14917 (char *) "self", NULL
14918 };
14919
14920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingRect",kwnames,&obj0)) goto fail;
14921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14922 if (SWIG_arg_fail(1)) SWIG_fail;
14923 {
14924 PyThreadState* __tstate = wxPyBeginAllowThreads();
14925 result = wxDC_GetClippingRect(arg1);
14926
14927 wxPyEndAllowThreads(__tstate);
14928 if (PyErr_Occurred()) SWIG_fail;
14929 }
14930 {
14931 wxRect * resultptr;
14932 resultptr = new wxRect((wxRect &)(result));
14933 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
14934 }
14935 return resultobj;
14936 fail:
14937 return NULL;
14938 }
14939
14940
14941 static PyObject *_wrap_DC_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
14942 PyObject *resultobj;
14943 wxDC *arg1 = (wxDC *) 0 ;
14944 int result;
14945 PyObject * obj0 = 0 ;
14946 char *kwnames[] = {
14947 (char *) "self", NULL
14948 };
14949
14950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharHeight",kwnames,&obj0)) goto fail;
14951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14952 if (SWIG_arg_fail(1)) SWIG_fail;
14953 {
14954 PyThreadState* __tstate = wxPyBeginAllowThreads();
14955 result = (int)((wxDC const *)arg1)->GetCharHeight();
14956
14957 wxPyEndAllowThreads(__tstate);
14958 if (PyErr_Occurred()) SWIG_fail;
14959 }
14960 {
14961 resultobj = SWIG_From_int((int)(result));
14962 }
14963 return resultobj;
14964 fail:
14965 return NULL;
14966 }
14967
14968
14969 static PyObject *_wrap_DC_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
14970 PyObject *resultobj;
14971 wxDC *arg1 = (wxDC *) 0 ;
14972 int result;
14973 PyObject * obj0 = 0 ;
14974 char *kwnames[] = {
14975 (char *) "self", NULL
14976 };
14977
14978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharWidth",kwnames,&obj0)) goto fail;
14979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14980 if (SWIG_arg_fail(1)) SWIG_fail;
14981 {
14982 PyThreadState* __tstate = wxPyBeginAllowThreads();
14983 result = (int)((wxDC const *)arg1)->GetCharWidth();
14984
14985 wxPyEndAllowThreads(__tstate);
14986 if (PyErr_Occurred()) SWIG_fail;
14987 }
14988 {
14989 resultobj = SWIG_From_int((int)(result));
14990 }
14991 return resultobj;
14992 fail:
14993 return NULL;
14994 }
14995
14996
14997 static PyObject *_wrap_DC_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
14998 PyObject *resultobj;
14999 wxDC *arg1 = (wxDC *) 0 ;
15000 wxString *arg2 = 0 ;
15001 int *arg3 = (int *) 0 ;
15002 int *arg4 = (int *) 0 ;
15003 bool temp2 = false ;
15004 int temp3 ;
15005 int res3 = 0 ;
15006 int temp4 ;
15007 int res4 = 0 ;
15008 PyObject * obj0 = 0 ;
15009 PyObject * obj1 = 0 ;
15010 char *kwnames[] = {
15011 (char *) "self",(char *) "string", NULL
15012 };
15013
15014 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15015 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
15017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15018 if (SWIG_arg_fail(1)) SWIG_fail;
15019 {
15020 arg2 = wxString_in_helper(obj1);
15021 if (arg2 == NULL) SWIG_fail;
15022 temp2 = true;
15023 }
15024 {
15025 PyThreadState* __tstate = wxPyBeginAllowThreads();
15026 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
15027
15028 wxPyEndAllowThreads(__tstate);
15029 if (PyErr_Occurred()) SWIG_fail;
15030 }
15031 Py_INCREF(Py_None); resultobj = Py_None;
15032 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15033 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15034 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15035 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15036 {
15037 if (temp2)
15038 delete arg2;
15039 }
15040 return resultobj;
15041 fail:
15042 {
15043 if (temp2)
15044 delete arg2;
15045 }
15046 return NULL;
15047 }
15048
15049
15050 static PyObject *_wrap_DC_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15051 PyObject *resultobj;
15052 wxDC *arg1 = (wxDC *) 0 ;
15053 wxString *arg2 = 0 ;
15054 int *arg3 = (int *) 0 ;
15055 int *arg4 = (int *) 0 ;
15056 int *arg5 = (int *) 0 ;
15057 int *arg6 = (int *) 0 ;
15058 wxFont *arg7 = (wxFont *) NULL ;
15059 bool temp2 = false ;
15060 int temp3 ;
15061 int res3 = 0 ;
15062 int temp4 ;
15063 int res4 = 0 ;
15064 int temp5 ;
15065 int res5 = 0 ;
15066 int temp6 ;
15067 int res6 = 0 ;
15068 PyObject * obj0 = 0 ;
15069 PyObject * obj1 = 0 ;
15070 PyObject * obj2 = 0 ;
15071 char *kwnames[] = {
15072 (char *) "self",(char *) "string",(char *) "font", NULL
15073 };
15074
15075 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15076 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15077 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15078 arg6 = &temp6; res6 = SWIG_NEWOBJ;
15079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15081 if (SWIG_arg_fail(1)) SWIG_fail;
15082 {
15083 arg2 = wxString_in_helper(obj1);
15084 if (arg2 == NULL) SWIG_fail;
15085 temp2 = true;
15086 }
15087 if (obj2) {
15088 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15089 if (SWIG_arg_fail(7)) SWIG_fail;
15090 }
15091 {
15092 PyThreadState* __tstate = wxPyBeginAllowThreads();
15093 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
15094
15095 wxPyEndAllowThreads(__tstate);
15096 if (PyErr_Occurred()) SWIG_fail;
15097 }
15098 Py_INCREF(Py_None); resultobj = Py_None;
15099 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15100 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15101 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15102 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15103 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15104 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15105 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
15106 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
15107 {
15108 if (temp2)
15109 delete arg2;
15110 }
15111 return resultobj;
15112 fail:
15113 {
15114 if (temp2)
15115 delete arg2;
15116 }
15117 return NULL;
15118 }
15119
15120
15121 static PyObject *_wrap_DC_GetMultiLineTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15122 PyObject *resultobj;
15123 wxDC *arg1 = (wxDC *) 0 ;
15124 wxString *arg2 = 0 ;
15125 int *arg3 = (int *) 0 ;
15126 int *arg4 = (int *) 0 ;
15127 int *arg5 = (int *) 0 ;
15128 wxFont *arg6 = (wxFont *) NULL ;
15129 bool temp2 = false ;
15130 int temp3 ;
15131 int res3 = 0 ;
15132 int temp4 ;
15133 int res4 = 0 ;
15134 int temp5 ;
15135 int res5 = 0 ;
15136 PyObject * obj0 = 0 ;
15137 PyObject * obj1 = 0 ;
15138 PyObject * obj2 = 0 ;
15139 char *kwnames[] = {
15140 (char *) "self",(char *) "text",(char *) "font", NULL
15141 };
15142
15143 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15144 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15145 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetMultiLineTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15148 if (SWIG_arg_fail(1)) SWIG_fail;
15149 {
15150 arg2 = wxString_in_helper(obj1);
15151 if (arg2 == NULL) SWIG_fail;
15152 temp2 = true;
15153 }
15154 if (obj2) {
15155 SWIG_Python_ConvertPtr(obj2, (void **)&arg6, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15156 if (SWIG_arg_fail(6)) SWIG_fail;
15157 }
15158 {
15159 PyThreadState* __tstate = wxPyBeginAllowThreads();
15160 (arg1)->GetMultiLineTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6);
15161
15162 wxPyEndAllowThreads(__tstate);
15163 if (PyErr_Occurred()) SWIG_fail;
15164 }
15165 Py_INCREF(Py_None); resultobj = Py_None;
15166 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15167 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15168 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15169 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15170 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15171 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15172 {
15173 if (temp2)
15174 delete arg2;
15175 }
15176 return resultobj;
15177 fail:
15178 {
15179 if (temp2)
15180 delete arg2;
15181 }
15182 return NULL;
15183 }
15184
15185
15186 static PyObject *_wrap_DC_GetPartialTextExtents(PyObject *, PyObject *args, PyObject *kwargs) {
15187 PyObject *resultobj;
15188 wxDC *arg1 = (wxDC *) 0 ;
15189 wxString *arg2 = 0 ;
15190 wxArrayInt result;
15191 bool temp2 = false ;
15192 PyObject * obj0 = 0 ;
15193 PyObject * obj1 = 0 ;
15194 char *kwnames[] = {
15195 (char *) "self",(char *) "text", NULL
15196 };
15197
15198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPartialTextExtents",kwnames,&obj0,&obj1)) goto fail;
15199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15200 if (SWIG_arg_fail(1)) SWIG_fail;
15201 {
15202 arg2 = wxString_in_helper(obj1);
15203 if (arg2 == NULL) SWIG_fail;
15204 temp2 = true;
15205 }
15206 {
15207 PyThreadState* __tstate = wxPyBeginAllowThreads();
15208 result = wxDC_GetPartialTextExtents(arg1,(wxString const &)*arg2);
15209
15210 wxPyEndAllowThreads(__tstate);
15211 if (PyErr_Occurred()) SWIG_fail;
15212 }
15213 {
15214 resultobj = PyList_New(0);
15215 size_t idx;
15216 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15217 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15218 PyList_Append(resultobj, val);
15219 Py_DECREF(val);
15220 }
15221 }
15222 {
15223 if (temp2)
15224 delete arg2;
15225 }
15226 return resultobj;
15227 fail:
15228 {
15229 if (temp2)
15230 delete arg2;
15231 }
15232 return NULL;
15233 }
15234
15235
15236 static PyObject *_wrap_DC_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
15237 PyObject *resultobj;
15238 wxDC *arg1 = (wxDC *) 0 ;
15239 wxSize result;
15240 PyObject * obj0 = 0 ;
15241 char *kwnames[] = {
15242 (char *) "self", NULL
15243 };
15244
15245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSize",kwnames,&obj0)) goto fail;
15246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15247 if (SWIG_arg_fail(1)) SWIG_fail;
15248 {
15249 PyThreadState* __tstate = wxPyBeginAllowThreads();
15250 result = (arg1)->GetSize();
15251
15252 wxPyEndAllowThreads(__tstate);
15253 if (PyErr_Occurred()) SWIG_fail;
15254 }
15255 {
15256 wxSize * resultptr;
15257 resultptr = new wxSize((wxSize &)(result));
15258 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15259 }
15260 return resultobj;
15261 fail:
15262 return NULL;
15263 }
15264
15265
15266 static PyObject *_wrap_DC_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15267 PyObject *resultobj;
15268 wxDC *arg1 = (wxDC *) 0 ;
15269 int *arg2 = (int *) 0 ;
15270 int *arg3 = (int *) 0 ;
15271 int temp2 ;
15272 int res2 = 0 ;
15273 int temp3 ;
15274 int res3 = 0 ;
15275 PyObject * obj0 = 0 ;
15276 char *kwnames[] = {
15277 (char *) "self", NULL
15278 };
15279
15280 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15281 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeTuple",kwnames,&obj0)) goto fail;
15283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15284 if (SWIG_arg_fail(1)) SWIG_fail;
15285 {
15286 PyThreadState* __tstate = wxPyBeginAllowThreads();
15287 (arg1)->GetSize(arg2,arg3);
15288
15289 wxPyEndAllowThreads(__tstate);
15290 if (PyErr_Occurred()) SWIG_fail;
15291 }
15292 Py_INCREF(Py_None); resultobj = Py_None;
15293 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15294 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15295 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15296 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15297 return resultobj;
15298 fail:
15299 return NULL;
15300 }
15301
15302
15303 static PyObject *_wrap_DC_GetSizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
15304 PyObject *resultobj;
15305 wxDC *arg1 = (wxDC *) 0 ;
15306 wxSize result;
15307 PyObject * obj0 = 0 ;
15308 char *kwnames[] = {
15309 (char *) "self", NULL
15310 };
15311
15312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMM",kwnames,&obj0)) goto fail;
15313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15314 if (SWIG_arg_fail(1)) SWIG_fail;
15315 {
15316 PyThreadState* __tstate = wxPyBeginAllowThreads();
15317 result = ((wxDC const *)arg1)->GetSizeMM();
15318
15319 wxPyEndAllowThreads(__tstate);
15320 if (PyErr_Occurred()) SWIG_fail;
15321 }
15322 {
15323 wxSize * resultptr;
15324 resultptr = new wxSize((wxSize &)(result));
15325 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15326 }
15327 return resultobj;
15328 fail:
15329 return NULL;
15330 }
15331
15332
15333 static PyObject *_wrap_DC_GetSizeMMTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15334 PyObject *resultobj;
15335 wxDC *arg1 = (wxDC *) 0 ;
15336 int *arg2 = (int *) 0 ;
15337 int *arg3 = (int *) 0 ;
15338 int temp2 ;
15339 int res2 = 0 ;
15340 int temp3 ;
15341 int res3 = 0 ;
15342 PyObject * obj0 = 0 ;
15343 char *kwnames[] = {
15344 (char *) "self", NULL
15345 };
15346
15347 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15348 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMMTuple",kwnames,&obj0)) goto fail;
15350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15351 if (SWIG_arg_fail(1)) SWIG_fail;
15352 {
15353 PyThreadState* __tstate = wxPyBeginAllowThreads();
15354 ((wxDC const *)arg1)->GetSizeMM(arg2,arg3);
15355
15356 wxPyEndAllowThreads(__tstate);
15357 if (PyErr_Occurred()) SWIG_fail;
15358 }
15359 Py_INCREF(Py_None); resultobj = Py_None;
15360 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15361 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15362 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15363 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15364 return resultobj;
15365 fail:
15366 return NULL;
15367 }
15368
15369
15370 static PyObject *_wrap_DC_DeviceToLogicalX(PyObject *, PyObject *args, PyObject *kwargs) {
15371 PyObject *resultobj;
15372 wxDC *arg1 = (wxDC *) 0 ;
15373 int arg2 ;
15374 int result;
15375 PyObject * obj0 = 0 ;
15376 PyObject * obj1 = 0 ;
15377 char *kwnames[] = {
15378 (char *) "self",(char *) "x", NULL
15379 };
15380
15381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalX",kwnames,&obj0,&obj1)) goto fail;
15382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15383 if (SWIG_arg_fail(1)) SWIG_fail;
15384 {
15385 arg2 = (int)(SWIG_As_int(obj1));
15386 if (SWIG_arg_fail(2)) SWIG_fail;
15387 }
15388 {
15389 PyThreadState* __tstate = wxPyBeginAllowThreads();
15390 result = (int)((wxDC const *)arg1)->DeviceToLogicalX(arg2);
15391
15392 wxPyEndAllowThreads(__tstate);
15393 if (PyErr_Occurred()) SWIG_fail;
15394 }
15395 {
15396 resultobj = SWIG_From_int((int)(result));
15397 }
15398 return resultobj;
15399 fail:
15400 return NULL;
15401 }
15402
15403
15404 static PyObject *_wrap_DC_DeviceToLogicalY(PyObject *, PyObject *args, PyObject *kwargs) {
15405 PyObject *resultobj;
15406 wxDC *arg1 = (wxDC *) 0 ;
15407 int arg2 ;
15408 int result;
15409 PyObject * obj0 = 0 ;
15410 PyObject * obj1 = 0 ;
15411 char *kwnames[] = {
15412 (char *) "self",(char *) "y", NULL
15413 };
15414
15415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalY",kwnames,&obj0,&obj1)) goto fail;
15416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15417 if (SWIG_arg_fail(1)) SWIG_fail;
15418 {
15419 arg2 = (int)(SWIG_As_int(obj1));
15420 if (SWIG_arg_fail(2)) SWIG_fail;
15421 }
15422 {
15423 PyThreadState* __tstate = wxPyBeginAllowThreads();
15424 result = (int)((wxDC const *)arg1)->DeviceToLogicalY(arg2);
15425
15426 wxPyEndAllowThreads(__tstate);
15427 if (PyErr_Occurred()) SWIG_fail;
15428 }
15429 {
15430 resultobj = SWIG_From_int((int)(result));
15431 }
15432 return resultobj;
15433 fail:
15434 return NULL;
15435 }
15436
15437
15438 static PyObject *_wrap_DC_DeviceToLogicalXRel(PyObject *, PyObject *args, PyObject *kwargs) {
15439 PyObject *resultobj;
15440 wxDC *arg1 = (wxDC *) 0 ;
15441 int arg2 ;
15442 int result;
15443 PyObject * obj0 = 0 ;
15444 PyObject * obj1 = 0 ;
15445 char *kwnames[] = {
15446 (char *) "self",(char *) "x", NULL
15447 };
15448
15449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalXRel",kwnames,&obj0,&obj1)) goto fail;
15450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15451 if (SWIG_arg_fail(1)) SWIG_fail;
15452 {
15453 arg2 = (int)(SWIG_As_int(obj1));
15454 if (SWIG_arg_fail(2)) SWIG_fail;
15455 }
15456 {
15457 PyThreadState* __tstate = wxPyBeginAllowThreads();
15458 result = (int)((wxDC const *)arg1)->DeviceToLogicalXRel(arg2);
15459
15460 wxPyEndAllowThreads(__tstate);
15461 if (PyErr_Occurred()) SWIG_fail;
15462 }
15463 {
15464 resultobj = SWIG_From_int((int)(result));
15465 }
15466 return resultobj;
15467 fail:
15468 return NULL;
15469 }
15470
15471
15472 static PyObject *_wrap_DC_DeviceToLogicalYRel(PyObject *, PyObject *args, PyObject *kwargs) {
15473 PyObject *resultobj;
15474 wxDC *arg1 = (wxDC *) 0 ;
15475 int arg2 ;
15476 int result;
15477 PyObject * obj0 = 0 ;
15478 PyObject * obj1 = 0 ;
15479 char *kwnames[] = {
15480 (char *) "self",(char *) "y", NULL
15481 };
15482
15483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalYRel",kwnames,&obj0,&obj1)) goto fail;
15484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15485 if (SWIG_arg_fail(1)) SWIG_fail;
15486 {
15487 arg2 = (int)(SWIG_As_int(obj1));
15488 if (SWIG_arg_fail(2)) SWIG_fail;
15489 }
15490 {
15491 PyThreadState* __tstate = wxPyBeginAllowThreads();
15492 result = (int)((wxDC const *)arg1)->DeviceToLogicalYRel(arg2);
15493
15494 wxPyEndAllowThreads(__tstate);
15495 if (PyErr_Occurred()) SWIG_fail;
15496 }
15497 {
15498 resultobj = SWIG_From_int((int)(result));
15499 }
15500 return resultobj;
15501 fail:
15502 return NULL;
15503 }
15504
15505
15506 static PyObject *_wrap_DC_LogicalToDeviceX(PyObject *, PyObject *args, PyObject *kwargs) {
15507 PyObject *resultobj;
15508 wxDC *arg1 = (wxDC *) 0 ;
15509 int arg2 ;
15510 int result;
15511 PyObject * obj0 = 0 ;
15512 PyObject * obj1 = 0 ;
15513 char *kwnames[] = {
15514 (char *) "self",(char *) "x", NULL
15515 };
15516
15517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceX",kwnames,&obj0,&obj1)) goto fail;
15518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15519 if (SWIG_arg_fail(1)) SWIG_fail;
15520 {
15521 arg2 = (int)(SWIG_As_int(obj1));
15522 if (SWIG_arg_fail(2)) SWIG_fail;
15523 }
15524 {
15525 PyThreadState* __tstate = wxPyBeginAllowThreads();
15526 result = (int)((wxDC const *)arg1)->LogicalToDeviceX(arg2);
15527
15528 wxPyEndAllowThreads(__tstate);
15529 if (PyErr_Occurred()) SWIG_fail;
15530 }
15531 {
15532 resultobj = SWIG_From_int((int)(result));
15533 }
15534 return resultobj;
15535 fail:
15536 return NULL;
15537 }
15538
15539
15540 static PyObject *_wrap_DC_LogicalToDeviceY(PyObject *, PyObject *args, PyObject *kwargs) {
15541 PyObject *resultobj;
15542 wxDC *arg1 = (wxDC *) 0 ;
15543 int arg2 ;
15544 int result;
15545 PyObject * obj0 = 0 ;
15546 PyObject * obj1 = 0 ;
15547 char *kwnames[] = {
15548 (char *) "self",(char *) "y", NULL
15549 };
15550
15551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceY",kwnames,&obj0,&obj1)) goto fail;
15552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15553 if (SWIG_arg_fail(1)) SWIG_fail;
15554 {
15555 arg2 = (int)(SWIG_As_int(obj1));
15556 if (SWIG_arg_fail(2)) SWIG_fail;
15557 }
15558 {
15559 PyThreadState* __tstate = wxPyBeginAllowThreads();
15560 result = (int)((wxDC const *)arg1)->LogicalToDeviceY(arg2);
15561
15562 wxPyEndAllowThreads(__tstate);
15563 if (PyErr_Occurred()) SWIG_fail;
15564 }
15565 {
15566 resultobj = SWIG_From_int((int)(result));
15567 }
15568 return resultobj;
15569 fail:
15570 return NULL;
15571 }
15572
15573
15574 static PyObject *_wrap_DC_LogicalToDeviceXRel(PyObject *, PyObject *args, PyObject *kwargs) {
15575 PyObject *resultobj;
15576 wxDC *arg1 = (wxDC *) 0 ;
15577 int arg2 ;
15578 int result;
15579 PyObject * obj0 = 0 ;
15580 PyObject * obj1 = 0 ;
15581 char *kwnames[] = {
15582 (char *) "self",(char *) "x", NULL
15583 };
15584
15585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceXRel",kwnames,&obj0,&obj1)) goto fail;
15586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15587 if (SWIG_arg_fail(1)) SWIG_fail;
15588 {
15589 arg2 = (int)(SWIG_As_int(obj1));
15590 if (SWIG_arg_fail(2)) SWIG_fail;
15591 }
15592 {
15593 PyThreadState* __tstate = wxPyBeginAllowThreads();
15594 result = (int)((wxDC const *)arg1)->LogicalToDeviceXRel(arg2);
15595
15596 wxPyEndAllowThreads(__tstate);
15597 if (PyErr_Occurred()) SWIG_fail;
15598 }
15599 {
15600 resultobj = SWIG_From_int((int)(result));
15601 }
15602 return resultobj;
15603 fail:
15604 return NULL;
15605 }
15606
15607
15608 static PyObject *_wrap_DC_LogicalToDeviceYRel(PyObject *, PyObject *args, PyObject *kwargs) {
15609 PyObject *resultobj;
15610 wxDC *arg1 = (wxDC *) 0 ;
15611 int arg2 ;
15612 int result;
15613 PyObject * obj0 = 0 ;
15614 PyObject * obj1 = 0 ;
15615 char *kwnames[] = {
15616 (char *) "self",(char *) "y", NULL
15617 };
15618
15619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceYRel",kwnames,&obj0,&obj1)) goto fail;
15620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15621 if (SWIG_arg_fail(1)) SWIG_fail;
15622 {
15623 arg2 = (int)(SWIG_As_int(obj1));
15624 if (SWIG_arg_fail(2)) SWIG_fail;
15625 }
15626 {
15627 PyThreadState* __tstate = wxPyBeginAllowThreads();
15628 result = (int)((wxDC const *)arg1)->LogicalToDeviceYRel(arg2);
15629
15630 wxPyEndAllowThreads(__tstate);
15631 if (PyErr_Occurred()) SWIG_fail;
15632 }
15633 {
15634 resultobj = SWIG_From_int((int)(result));
15635 }
15636 return resultobj;
15637 fail:
15638 return NULL;
15639 }
15640
15641
15642 static PyObject *_wrap_DC_CanDrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
15643 PyObject *resultobj;
15644 wxDC *arg1 = (wxDC *) 0 ;
15645 bool result;
15646 PyObject * obj0 = 0 ;
15647 char *kwnames[] = {
15648 (char *) "self", NULL
15649 };
15650
15651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanDrawBitmap",kwnames,&obj0)) goto fail;
15652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15653 if (SWIG_arg_fail(1)) SWIG_fail;
15654 {
15655 PyThreadState* __tstate = wxPyBeginAllowThreads();
15656 result = (bool)((wxDC const *)arg1)->CanDrawBitmap();
15657
15658 wxPyEndAllowThreads(__tstate);
15659 if (PyErr_Occurred()) SWIG_fail;
15660 }
15661 {
15662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15663 }
15664 return resultobj;
15665 fail:
15666 return NULL;
15667 }
15668
15669
15670 static PyObject *_wrap_DC_CanGetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15671 PyObject *resultobj;
15672 wxDC *arg1 = (wxDC *) 0 ;
15673 bool result;
15674 PyObject * obj0 = 0 ;
15675 char *kwnames[] = {
15676 (char *) "self", NULL
15677 };
15678
15679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanGetTextExtent",kwnames,&obj0)) goto fail;
15680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15681 if (SWIG_arg_fail(1)) SWIG_fail;
15682 {
15683 PyThreadState* __tstate = wxPyBeginAllowThreads();
15684 result = (bool)((wxDC const *)arg1)->CanGetTextExtent();
15685
15686 wxPyEndAllowThreads(__tstate);
15687 if (PyErr_Occurred()) SWIG_fail;
15688 }
15689 {
15690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15691 }
15692 return resultobj;
15693 fail:
15694 return NULL;
15695 }
15696
15697
15698 static PyObject *_wrap_DC_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
15699 PyObject *resultobj;
15700 wxDC *arg1 = (wxDC *) 0 ;
15701 int result;
15702 PyObject * obj0 = 0 ;
15703 char *kwnames[] = {
15704 (char *) "self", NULL
15705 };
15706
15707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDepth",kwnames,&obj0)) goto fail;
15708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15709 if (SWIG_arg_fail(1)) SWIG_fail;
15710 {
15711 PyThreadState* __tstate = wxPyBeginAllowThreads();
15712 result = (int)((wxDC const *)arg1)->GetDepth();
15713
15714 wxPyEndAllowThreads(__tstate);
15715 if (PyErr_Occurred()) SWIG_fail;
15716 }
15717 {
15718 resultobj = SWIG_From_int((int)(result));
15719 }
15720 return resultobj;
15721 fail:
15722 return NULL;
15723 }
15724
15725
15726 static PyObject *_wrap_DC_GetPPI(PyObject *, PyObject *args, PyObject *kwargs) {
15727 PyObject *resultobj;
15728 wxDC *arg1 = (wxDC *) 0 ;
15729 wxSize result;
15730 PyObject * obj0 = 0 ;
15731 char *kwnames[] = {
15732 (char *) "self", NULL
15733 };
15734
15735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPPI",kwnames,&obj0)) goto fail;
15736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15737 if (SWIG_arg_fail(1)) SWIG_fail;
15738 {
15739 PyThreadState* __tstate = wxPyBeginAllowThreads();
15740 result = ((wxDC const *)arg1)->GetPPI();
15741
15742 wxPyEndAllowThreads(__tstate);
15743 if (PyErr_Occurred()) SWIG_fail;
15744 }
15745 {
15746 wxSize * resultptr;
15747 resultptr = new wxSize((wxSize &)(result));
15748 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15749 }
15750 return resultobj;
15751 fail:
15752 return NULL;
15753 }
15754
15755
15756 static PyObject *_wrap_DC_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
15757 PyObject *resultobj;
15758 wxDC *arg1 = (wxDC *) 0 ;
15759 bool result;
15760 PyObject * obj0 = 0 ;
15761 char *kwnames[] = {
15762 (char *) "self", NULL
15763 };
15764
15765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Ok",kwnames,&obj0)) goto fail;
15766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15767 if (SWIG_arg_fail(1)) SWIG_fail;
15768 {
15769 PyThreadState* __tstate = wxPyBeginAllowThreads();
15770 result = (bool)((wxDC const *)arg1)->Ok();
15771
15772 wxPyEndAllowThreads(__tstate);
15773 if (PyErr_Occurred()) SWIG_fail;
15774 }
15775 {
15776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15777 }
15778 return resultobj;
15779 fail:
15780 return NULL;
15781 }
15782
15783
15784 static PyObject *_wrap_DC_GetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
15785 PyObject *resultobj;
15786 wxDC *arg1 = (wxDC *) 0 ;
15787 int result;
15788 PyObject * obj0 = 0 ;
15789 char *kwnames[] = {
15790 (char *) "self", NULL
15791 };
15792
15793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackgroundMode",kwnames,&obj0)) goto fail;
15794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15795 if (SWIG_arg_fail(1)) SWIG_fail;
15796 {
15797 PyThreadState* __tstate = wxPyBeginAllowThreads();
15798 result = (int)((wxDC const *)arg1)->GetBackgroundMode();
15799
15800 wxPyEndAllowThreads(__tstate);
15801 if (PyErr_Occurred()) SWIG_fail;
15802 }
15803 {
15804 resultobj = SWIG_From_int((int)(result));
15805 }
15806 return resultobj;
15807 fail:
15808 return NULL;
15809 }
15810
15811
15812 static PyObject *_wrap_DC_GetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15813 PyObject *resultobj;
15814 wxDC *arg1 = (wxDC *) 0 ;
15815 wxBrush *result;
15816 PyObject * obj0 = 0 ;
15817 char *kwnames[] = {
15818 (char *) "self", NULL
15819 };
15820
15821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackground",kwnames,&obj0)) goto fail;
15822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15823 if (SWIG_arg_fail(1)) SWIG_fail;
15824 {
15825 PyThreadState* __tstate = wxPyBeginAllowThreads();
15826 {
15827 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBackground();
15828 result = (wxBrush *) &_result_ref;
15829 }
15830
15831 wxPyEndAllowThreads(__tstate);
15832 if (PyErr_Occurred()) SWIG_fail;
15833 }
15834 {
15835 wxBrush* resultptr = new wxBrush(*result);
15836 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
15837 }
15838 return resultobj;
15839 fail:
15840 return NULL;
15841 }
15842
15843
15844 static PyObject *_wrap_DC_GetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
15845 PyObject *resultobj;
15846 wxDC *arg1 = (wxDC *) 0 ;
15847 wxBrush *result;
15848 PyObject * obj0 = 0 ;
15849 char *kwnames[] = {
15850 (char *) "self", NULL
15851 };
15852
15853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBrush",kwnames,&obj0)) goto fail;
15854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15855 if (SWIG_arg_fail(1)) SWIG_fail;
15856 {
15857 PyThreadState* __tstate = wxPyBeginAllowThreads();
15858 {
15859 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBrush();
15860 result = (wxBrush *) &_result_ref;
15861 }
15862
15863 wxPyEndAllowThreads(__tstate);
15864 if (PyErr_Occurred()) SWIG_fail;
15865 }
15866 {
15867 wxBrush* resultptr = new wxBrush(*result);
15868 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
15869 }
15870 return resultobj;
15871 fail:
15872 return NULL;
15873 }
15874
15875
15876 static PyObject *_wrap_DC_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
15877 PyObject *resultobj;
15878 wxDC *arg1 = (wxDC *) 0 ;
15879 wxFont *result;
15880 PyObject * obj0 = 0 ;
15881 char *kwnames[] = {
15882 (char *) "self", NULL
15883 };
15884
15885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetFont",kwnames,&obj0)) goto fail;
15886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15887 if (SWIG_arg_fail(1)) SWIG_fail;
15888 {
15889 PyThreadState* __tstate = wxPyBeginAllowThreads();
15890 {
15891 wxFont const &_result_ref = ((wxDC const *)arg1)->GetFont();
15892 result = (wxFont *) &_result_ref;
15893 }
15894
15895 wxPyEndAllowThreads(__tstate);
15896 if (PyErr_Occurred()) SWIG_fail;
15897 }
15898 {
15899 wxFont* resultptr = new wxFont(*result);
15900 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxFont, 1);
15901 }
15902 return resultobj;
15903 fail:
15904 return NULL;
15905 }
15906
15907
15908 static PyObject *_wrap_DC_GetPen(PyObject *, PyObject *args, PyObject *kwargs) {
15909 PyObject *resultobj;
15910 wxDC *arg1 = (wxDC *) 0 ;
15911 wxPen *result;
15912 PyObject * obj0 = 0 ;
15913 char *kwnames[] = {
15914 (char *) "self", NULL
15915 };
15916
15917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPen",kwnames,&obj0)) goto fail;
15918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15919 if (SWIG_arg_fail(1)) SWIG_fail;
15920 {
15921 PyThreadState* __tstate = wxPyBeginAllowThreads();
15922 {
15923 wxPen const &_result_ref = ((wxDC const *)arg1)->GetPen();
15924 result = (wxPen *) &_result_ref;
15925 }
15926
15927 wxPyEndAllowThreads(__tstate);
15928 if (PyErr_Occurred()) SWIG_fail;
15929 }
15930 {
15931 wxPen* resultptr = new wxPen(*result);
15932 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxPen, 1);
15933 }
15934 return resultobj;
15935 fail:
15936 return NULL;
15937 }
15938
15939
15940 static PyObject *_wrap_DC_GetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15941 PyObject *resultobj;
15942 wxDC *arg1 = (wxDC *) 0 ;
15943 wxColour *result;
15944 PyObject * obj0 = 0 ;
15945 char *kwnames[] = {
15946 (char *) "self", NULL
15947 };
15948
15949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextBackground",kwnames,&obj0)) goto fail;
15950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15951 if (SWIG_arg_fail(1)) SWIG_fail;
15952 {
15953 PyThreadState* __tstate = wxPyBeginAllowThreads();
15954 {
15955 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextBackground();
15956 result = (wxColour *) &_result_ref;
15957 }
15958
15959 wxPyEndAllowThreads(__tstate);
15960 if (PyErr_Occurred()) SWIG_fail;
15961 }
15962 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
15963 return resultobj;
15964 fail:
15965 return NULL;
15966 }
15967
15968
15969 static PyObject *_wrap_DC_GetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
15970 PyObject *resultobj;
15971 wxDC *arg1 = (wxDC *) 0 ;
15972 wxColour *result;
15973 PyObject * obj0 = 0 ;
15974 char *kwnames[] = {
15975 (char *) "self", NULL
15976 };
15977
15978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextForeground",kwnames,&obj0)) goto fail;
15979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15980 if (SWIG_arg_fail(1)) SWIG_fail;
15981 {
15982 PyThreadState* __tstate = wxPyBeginAllowThreads();
15983 {
15984 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextForeground();
15985 result = (wxColour *) &_result_ref;
15986 }
15987
15988 wxPyEndAllowThreads(__tstate);
15989 if (PyErr_Occurred()) SWIG_fail;
15990 }
15991 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
15992 return resultobj;
15993 fail:
15994 return NULL;
15995 }
15996
15997
15998 static PyObject *_wrap_DC_SetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
15999 PyObject *resultobj;
16000 wxDC *arg1 = (wxDC *) 0 ;
16001 wxColour *arg2 = 0 ;
16002 wxColour temp2 ;
16003 PyObject * obj0 = 0 ;
16004 PyObject * obj1 = 0 ;
16005 char *kwnames[] = {
16006 (char *) "self",(char *) "colour", NULL
16007 };
16008
16009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextForeground",kwnames,&obj0,&obj1)) goto fail;
16010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16011 if (SWIG_arg_fail(1)) SWIG_fail;
16012 {
16013 arg2 = &temp2;
16014 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16015 }
16016 {
16017 PyThreadState* __tstate = wxPyBeginAllowThreads();
16018 (arg1)->SetTextForeground((wxColour const &)*arg2);
16019
16020 wxPyEndAllowThreads(__tstate);
16021 if (PyErr_Occurred()) SWIG_fail;
16022 }
16023 Py_INCREF(Py_None); resultobj = Py_None;
16024 return resultobj;
16025 fail:
16026 return NULL;
16027 }
16028
16029
16030 static PyObject *_wrap_DC_SetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16031 PyObject *resultobj;
16032 wxDC *arg1 = (wxDC *) 0 ;
16033 wxColour *arg2 = 0 ;
16034 wxColour temp2 ;
16035 PyObject * obj0 = 0 ;
16036 PyObject * obj1 = 0 ;
16037 char *kwnames[] = {
16038 (char *) "self",(char *) "colour", NULL
16039 };
16040
16041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextBackground",kwnames,&obj0,&obj1)) goto fail;
16042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16043 if (SWIG_arg_fail(1)) SWIG_fail;
16044 {
16045 arg2 = &temp2;
16046 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16047 }
16048 {
16049 PyThreadState* __tstate = wxPyBeginAllowThreads();
16050 (arg1)->SetTextBackground((wxColour const &)*arg2);
16051
16052 wxPyEndAllowThreads(__tstate);
16053 if (PyErr_Occurred()) SWIG_fail;
16054 }
16055 Py_INCREF(Py_None); resultobj = Py_None;
16056 return resultobj;
16057 fail:
16058 return NULL;
16059 }
16060
16061
16062 static PyObject *_wrap_DC_GetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16063 PyObject *resultobj;
16064 wxDC *arg1 = (wxDC *) 0 ;
16065 int result;
16066 PyObject * obj0 = 0 ;
16067 char *kwnames[] = {
16068 (char *) "self", NULL
16069 };
16070
16071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetMapMode",kwnames,&obj0)) goto fail;
16072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16073 if (SWIG_arg_fail(1)) SWIG_fail;
16074 {
16075 PyThreadState* __tstate = wxPyBeginAllowThreads();
16076 result = (int)((wxDC const *)arg1)->GetMapMode();
16077
16078 wxPyEndAllowThreads(__tstate);
16079 if (PyErr_Occurred()) SWIG_fail;
16080 }
16081 {
16082 resultobj = SWIG_From_int((int)(result));
16083 }
16084 return resultobj;
16085 fail:
16086 return NULL;
16087 }
16088
16089
16090 static PyObject *_wrap_DC_SetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16091 PyObject *resultobj;
16092 wxDC *arg1 = (wxDC *) 0 ;
16093 int arg2 ;
16094 PyObject * obj0 = 0 ;
16095 PyObject * obj1 = 0 ;
16096 char *kwnames[] = {
16097 (char *) "self",(char *) "mode", NULL
16098 };
16099
16100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetMapMode",kwnames,&obj0,&obj1)) goto fail;
16101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16102 if (SWIG_arg_fail(1)) SWIG_fail;
16103 {
16104 arg2 = (int)(SWIG_As_int(obj1));
16105 if (SWIG_arg_fail(2)) SWIG_fail;
16106 }
16107 {
16108 PyThreadState* __tstate = wxPyBeginAllowThreads();
16109 (arg1)->SetMapMode(arg2);
16110
16111 wxPyEndAllowThreads(__tstate);
16112 if (PyErr_Occurred()) SWIG_fail;
16113 }
16114 Py_INCREF(Py_None); resultobj = Py_None;
16115 return resultobj;
16116 fail:
16117 return NULL;
16118 }
16119
16120
16121 static PyObject *_wrap_DC_GetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16122 PyObject *resultobj;
16123 wxDC *arg1 = (wxDC *) 0 ;
16124 double *arg2 = (double *) 0 ;
16125 double *arg3 = (double *) 0 ;
16126 double temp2 ;
16127 int res2 = 0 ;
16128 double temp3 ;
16129 int res3 = 0 ;
16130 PyObject * obj0 = 0 ;
16131 char *kwnames[] = {
16132 (char *) "self", NULL
16133 };
16134
16135 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16136 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetUserScale",kwnames,&obj0)) goto fail;
16138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16139 if (SWIG_arg_fail(1)) SWIG_fail;
16140 {
16141 PyThreadState* __tstate = wxPyBeginAllowThreads();
16142 ((wxDC const *)arg1)->GetUserScale(arg2,arg3);
16143
16144 wxPyEndAllowThreads(__tstate);
16145 if (PyErr_Occurred()) SWIG_fail;
16146 }
16147 Py_INCREF(Py_None); resultobj = Py_None;
16148 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16149 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16150 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16151 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16152 return resultobj;
16153 fail:
16154 return NULL;
16155 }
16156
16157
16158 static PyObject *_wrap_DC_SetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16159 PyObject *resultobj;
16160 wxDC *arg1 = (wxDC *) 0 ;
16161 double arg2 ;
16162 double arg3 ;
16163 PyObject * obj0 = 0 ;
16164 PyObject * obj1 = 0 ;
16165 PyObject * obj2 = 0 ;
16166 char *kwnames[] = {
16167 (char *) "self",(char *) "x",(char *) "y", NULL
16168 };
16169
16170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetUserScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16172 if (SWIG_arg_fail(1)) SWIG_fail;
16173 {
16174 arg2 = (double)(SWIG_As_double(obj1));
16175 if (SWIG_arg_fail(2)) SWIG_fail;
16176 }
16177 {
16178 arg3 = (double)(SWIG_As_double(obj2));
16179 if (SWIG_arg_fail(3)) SWIG_fail;
16180 }
16181 {
16182 PyThreadState* __tstate = wxPyBeginAllowThreads();
16183 (arg1)->SetUserScale(arg2,arg3);
16184
16185 wxPyEndAllowThreads(__tstate);
16186 if (PyErr_Occurred()) SWIG_fail;
16187 }
16188 Py_INCREF(Py_None); resultobj = Py_None;
16189 return resultobj;
16190 fail:
16191 return NULL;
16192 }
16193
16194
16195 static PyObject *_wrap_DC_GetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16196 PyObject *resultobj;
16197 wxDC *arg1 = (wxDC *) 0 ;
16198 double *arg2 = (double *) 0 ;
16199 double *arg3 = (double *) 0 ;
16200 double temp2 ;
16201 int res2 = 0 ;
16202 double temp3 ;
16203 int res3 = 0 ;
16204 PyObject * obj0 = 0 ;
16205 char *kwnames[] = {
16206 (char *) "self", NULL
16207 };
16208
16209 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16210 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalScale",kwnames,&obj0)) goto fail;
16212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16213 if (SWIG_arg_fail(1)) SWIG_fail;
16214 {
16215 PyThreadState* __tstate = wxPyBeginAllowThreads();
16216 (arg1)->GetLogicalScale(arg2,arg3);
16217
16218 wxPyEndAllowThreads(__tstate);
16219 if (PyErr_Occurred()) SWIG_fail;
16220 }
16221 Py_INCREF(Py_None); resultobj = Py_None;
16222 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16223 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16224 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16225 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16226 return resultobj;
16227 fail:
16228 return NULL;
16229 }
16230
16231
16232 static PyObject *_wrap_DC_SetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16233 PyObject *resultobj;
16234 wxDC *arg1 = (wxDC *) 0 ;
16235 double arg2 ;
16236 double arg3 ;
16237 PyObject * obj0 = 0 ;
16238 PyObject * obj1 = 0 ;
16239 PyObject * obj2 = 0 ;
16240 char *kwnames[] = {
16241 (char *) "self",(char *) "x",(char *) "y", NULL
16242 };
16243
16244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16246 if (SWIG_arg_fail(1)) SWIG_fail;
16247 {
16248 arg2 = (double)(SWIG_As_double(obj1));
16249 if (SWIG_arg_fail(2)) SWIG_fail;
16250 }
16251 {
16252 arg3 = (double)(SWIG_As_double(obj2));
16253 if (SWIG_arg_fail(3)) SWIG_fail;
16254 }
16255 {
16256 PyThreadState* __tstate = wxPyBeginAllowThreads();
16257 (arg1)->SetLogicalScale(arg2,arg3);
16258
16259 wxPyEndAllowThreads(__tstate);
16260 if (PyErr_Occurred()) SWIG_fail;
16261 }
16262 Py_INCREF(Py_None); resultobj = Py_None;
16263 return resultobj;
16264 fail:
16265 return NULL;
16266 }
16267
16268
16269 static PyObject *_wrap_DC_GetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16270 PyObject *resultobj;
16271 wxDC *arg1 = (wxDC *) 0 ;
16272 wxPoint result;
16273 PyObject * obj0 = 0 ;
16274 char *kwnames[] = {
16275 (char *) "self", NULL
16276 };
16277
16278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOrigin",kwnames,&obj0)) goto fail;
16279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16280 if (SWIG_arg_fail(1)) SWIG_fail;
16281 {
16282 PyThreadState* __tstate = wxPyBeginAllowThreads();
16283 result = ((wxDC const *)arg1)->GetLogicalOrigin();
16284
16285 wxPyEndAllowThreads(__tstate);
16286 if (PyErr_Occurred()) SWIG_fail;
16287 }
16288 {
16289 wxPoint * resultptr;
16290 resultptr = new wxPoint((wxPoint &)(result));
16291 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16292 }
16293 return resultobj;
16294 fail:
16295 return NULL;
16296 }
16297
16298
16299 static PyObject *_wrap_DC_GetLogicalOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16300 PyObject *resultobj;
16301 wxDC *arg1 = (wxDC *) 0 ;
16302 int *arg2 = (int *) 0 ;
16303 int *arg3 = (int *) 0 ;
16304 int temp2 ;
16305 int res2 = 0 ;
16306 int temp3 ;
16307 int res3 = 0 ;
16308 PyObject * obj0 = 0 ;
16309 char *kwnames[] = {
16310 (char *) "self", NULL
16311 };
16312
16313 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16314 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOriginTuple",kwnames,&obj0)) goto fail;
16316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16317 if (SWIG_arg_fail(1)) SWIG_fail;
16318 {
16319 PyThreadState* __tstate = wxPyBeginAllowThreads();
16320 ((wxDC const *)arg1)->GetLogicalOrigin(arg2,arg3);
16321
16322 wxPyEndAllowThreads(__tstate);
16323 if (PyErr_Occurred()) SWIG_fail;
16324 }
16325 Py_INCREF(Py_None); resultobj = Py_None;
16326 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16327 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16328 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16329 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16330 return resultobj;
16331 fail:
16332 return NULL;
16333 }
16334
16335
16336 static PyObject *_wrap_DC_SetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16337 PyObject *resultobj;
16338 wxDC *arg1 = (wxDC *) 0 ;
16339 int arg2 ;
16340 int arg3 ;
16341 PyObject * obj0 = 0 ;
16342 PyObject * obj1 = 0 ;
16343 PyObject * obj2 = 0 ;
16344 char *kwnames[] = {
16345 (char *) "self",(char *) "x",(char *) "y", NULL
16346 };
16347
16348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
16349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16350 if (SWIG_arg_fail(1)) SWIG_fail;
16351 {
16352 arg2 = (int)(SWIG_As_int(obj1));
16353 if (SWIG_arg_fail(2)) SWIG_fail;
16354 }
16355 {
16356 arg3 = (int)(SWIG_As_int(obj2));
16357 if (SWIG_arg_fail(3)) SWIG_fail;
16358 }
16359 {
16360 PyThreadState* __tstate = wxPyBeginAllowThreads();
16361 (arg1)->SetLogicalOrigin(arg2,arg3);
16362
16363 wxPyEndAllowThreads(__tstate);
16364 if (PyErr_Occurred()) SWIG_fail;
16365 }
16366 Py_INCREF(Py_None); resultobj = Py_None;
16367 return resultobj;
16368 fail:
16369 return NULL;
16370 }
16371
16372
16373 static PyObject *_wrap_DC_SetLogicalOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16374 PyObject *resultobj;
16375 wxDC *arg1 = (wxDC *) 0 ;
16376 wxPoint *arg2 = 0 ;
16377 wxPoint temp2 ;
16378 PyObject * obj0 = 0 ;
16379 PyObject * obj1 = 0 ;
16380 char *kwnames[] = {
16381 (char *) "self",(char *) "point", NULL
16382 };
16383
16384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalOriginPoint",kwnames,&obj0,&obj1)) goto fail;
16385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16386 if (SWIG_arg_fail(1)) SWIG_fail;
16387 {
16388 arg2 = &temp2;
16389 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16390 }
16391 {
16392 PyThreadState* __tstate = wxPyBeginAllowThreads();
16393 wxDC_SetLogicalOriginPoint(arg1,(wxPoint const &)*arg2);
16394
16395 wxPyEndAllowThreads(__tstate);
16396 if (PyErr_Occurred()) SWIG_fail;
16397 }
16398 Py_INCREF(Py_None); resultobj = Py_None;
16399 return resultobj;
16400 fail:
16401 return NULL;
16402 }
16403
16404
16405 static PyObject *_wrap_DC_GetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16406 PyObject *resultobj;
16407 wxDC *arg1 = (wxDC *) 0 ;
16408 wxPoint result;
16409 PyObject * obj0 = 0 ;
16410 char *kwnames[] = {
16411 (char *) "self", NULL
16412 };
16413
16414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOrigin",kwnames,&obj0)) goto fail;
16415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16416 if (SWIG_arg_fail(1)) SWIG_fail;
16417 {
16418 PyThreadState* __tstate = wxPyBeginAllowThreads();
16419 result = ((wxDC const *)arg1)->GetDeviceOrigin();
16420
16421 wxPyEndAllowThreads(__tstate);
16422 if (PyErr_Occurred()) SWIG_fail;
16423 }
16424 {
16425 wxPoint * resultptr;
16426 resultptr = new wxPoint((wxPoint &)(result));
16427 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16428 }
16429 return resultobj;
16430 fail:
16431 return NULL;
16432 }
16433
16434
16435 static PyObject *_wrap_DC_GetDeviceOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16436 PyObject *resultobj;
16437 wxDC *arg1 = (wxDC *) 0 ;
16438 int *arg2 = (int *) 0 ;
16439 int *arg3 = (int *) 0 ;
16440 int temp2 ;
16441 int res2 = 0 ;
16442 int temp3 ;
16443 int res3 = 0 ;
16444 PyObject * obj0 = 0 ;
16445 char *kwnames[] = {
16446 (char *) "self", NULL
16447 };
16448
16449 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16450 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOriginTuple",kwnames,&obj0)) goto fail;
16452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16453 if (SWIG_arg_fail(1)) SWIG_fail;
16454 {
16455 PyThreadState* __tstate = wxPyBeginAllowThreads();
16456 ((wxDC const *)arg1)->GetDeviceOrigin(arg2,arg3);
16457
16458 wxPyEndAllowThreads(__tstate);
16459 if (PyErr_Occurred()) SWIG_fail;
16460 }
16461 Py_INCREF(Py_None); resultobj = Py_None;
16462 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16463 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16464 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16465 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16466 return resultobj;
16467 fail:
16468 return NULL;
16469 }
16470
16471
16472 static PyObject *_wrap_DC_SetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16473 PyObject *resultobj;
16474 wxDC *arg1 = (wxDC *) 0 ;
16475 int arg2 ;
16476 int arg3 ;
16477 PyObject * obj0 = 0 ;
16478 PyObject * obj1 = 0 ;
16479 PyObject * obj2 = 0 ;
16480 char *kwnames[] = {
16481 (char *) "self",(char *) "x",(char *) "y", NULL
16482 };
16483
16484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetDeviceOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
16485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16486 if (SWIG_arg_fail(1)) SWIG_fail;
16487 {
16488 arg2 = (int)(SWIG_As_int(obj1));
16489 if (SWIG_arg_fail(2)) SWIG_fail;
16490 }
16491 {
16492 arg3 = (int)(SWIG_As_int(obj2));
16493 if (SWIG_arg_fail(3)) SWIG_fail;
16494 }
16495 {
16496 PyThreadState* __tstate = wxPyBeginAllowThreads();
16497 (arg1)->SetDeviceOrigin(arg2,arg3);
16498
16499 wxPyEndAllowThreads(__tstate);
16500 if (PyErr_Occurred()) SWIG_fail;
16501 }
16502 Py_INCREF(Py_None); resultobj = Py_None;
16503 return resultobj;
16504 fail:
16505 return NULL;
16506 }
16507
16508
16509 static PyObject *_wrap_DC_SetDeviceOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16510 PyObject *resultobj;
16511 wxDC *arg1 = (wxDC *) 0 ;
16512 wxPoint *arg2 = 0 ;
16513 wxPoint temp2 ;
16514 PyObject * obj0 = 0 ;
16515 PyObject * obj1 = 0 ;
16516 char *kwnames[] = {
16517 (char *) "self",(char *) "point", NULL
16518 };
16519
16520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetDeviceOriginPoint",kwnames,&obj0,&obj1)) goto fail;
16521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16522 if (SWIG_arg_fail(1)) SWIG_fail;
16523 {
16524 arg2 = &temp2;
16525 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16526 }
16527 {
16528 PyThreadState* __tstate = wxPyBeginAllowThreads();
16529 wxDC_SetDeviceOriginPoint(arg1,(wxPoint const &)*arg2);
16530
16531 wxPyEndAllowThreads(__tstate);
16532 if (PyErr_Occurred()) SWIG_fail;
16533 }
16534 Py_INCREF(Py_None); resultobj = Py_None;
16535 return resultobj;
16536 fail:
16537 return NULL;
16538 }
16539
16540
16541 static PyObject *_wrap_DC_SetAxisOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16542 PyObject *resultobj;
16543 wxDC *arg1 = (wxDC *) 0 ;
16544 bool arg2 ;
16545 bool arg3 ;
16546 PyObject * obj0 = 0 ;
16547 PyObject * obj1 = 0 ;
16548 PyObject * obj2 = 0 ;
16549 char *kwnames[] = {
16550 (char *) "self",(char *) "xLeftRight",(char *) "yBottomUp", NULL
16551 };
16552
16553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetAxisOrientation",kwnames,&obj0,&obj1,&obj2)) goto fail;
16554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16555 if (SWIG_arg_fail(1)) SWIG_fail;
16556 {
16557 arg2 = (bool)(SWIG_As_bool(obj1));
16558 if (SWIG_arg_fail(2)) SWIG_fail;
16559 }
16560 {
16561 arg3 = (bool)(SWIG_As_bool(obj2));
16562 if (SWIG_arg_fail(3)) SWIG_fail;
16563 }
16564 {
16565 PyThreadState* __tstate = wxPyBeginAllowThreads();
16566 (arg1)->SetAxisOrientation(arg2,arg3);
16567
16568 wxPyEndAllowThreads(__tstate);
16569 if (PyErr_Occurred()) SWIG_fail;
16570 }
16571 Py_INCREF(Py_None); resultobj = Py_None;
16572 return resultobj;
16573 fail:
16574 return NULL;
16575 }
16576
16577
16578 static PyObject *_wrap_DC_GetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
16579 PyObject *resultobj;
16580 wxDC *arg1 = (wxDC *) 0 ;
16581 int result;
16582 PyObject * obj0 = 0 ;
16583 char *kwnames[] = {
16584 (char *) "self", NULL
16585 };
16586
16587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalFunction",kwnames,&obj0)) goto fail;
16588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16589 if (SWIG_arg_fail(1)) SWIG_fail;
16590 {
16591 PyThreadState* __tstate = wxPyBeginAllowThreads();
16592 result = (int)((wxDC const *)arg1)->GetLogicalFunction();
16593
16594 wxPyEndAllowThreads(__tstate);
16595 if (PyErr_Occurred()) SWIG_fail;
16596 }
16597 {
16598 resultobj = SWIG_From_int((int)(result));
16599 }
16600 return resultobj;
16601 fail:
16602 return NULL;
16603 }
16604
16605
16606 static PyObject *_wrap_DC_SetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
16607 PyObject *resultobj;
16608 wxDC *arg1 = (wxDC *) 0 ;
16609 int arg2 ;
16610 PyObject * obj0 = 0 ;
16611 PyObject * obj1 = 0 ;
16612 char *kwnames[] = {
16613 (char *) "self",(char *) "function", NULL
16614 };
16615
16616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalFunction",kwnames,&obj0,&obj1)) goto fail;
16617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16618 if (SWIG_arg_fail(1)) SWIG_fail;
16619 {
16620 arg2 = (int)(SWIG_As_int(obj1));
16621 if (SWIG_arg_fail(2)) SWIG_fail;
16622 }
16623 {
16624 PyThreadState* __tstate = wxPyBeginAllowThreads();
16625 (arg1)->SetLogicalFunction(arg2);
16626
16627 wxPyEndAllowThreads(__tstate);
16628 if (PyErr_Occurred()) SWIG_fail;
16629 }
16630 Py_INCREF(Py_None); resultobj = Py_None;
16631 return resultobj;
16632 fail:
16633 return NULL;
16634 }
16635
16636
16637 static PyObject *_wrap_DC_ComputeScaleAndOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16638 PyObject *resultobj;
16639 wxDC *arg1 = (wxDC *) 0 ;
16640 PyObject * obj0 = 0 ;
16641 char *kwnames[] = {
16642 (char *) "self", NULL
16643 };
16644
16645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ComputeScaleAndOrigin",kwnames,&obj0)) goto fail;
16646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16647 if (SWIG_arg_fail(1)) SWIG_fail;
16648 {
16649 PyThreadState* __tstate = wxPyBeginAllowThreads();
16650 (arg1)->ComputeScaleAndOrigin();
16651
16652 wxPyEndAllowThreads(__tstate);
16653 if (PyErr_Occurred()) SWIG_fail;
16654 }
16655 Py_INCREF(Py_None); resultobj = Py_None;
16656 return resultobj;
16657 fail:
16658 return NULL;
16659 }
16660
16661
16662 static PyObject *_wrap_DC_CalcBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16663 PyObject *resultobj;
16664 wxDC *arg1 = (wxDC *) 0 ;
16665 int arg2 ;
16666 int arg3 ;
16667 PyObject * obj0 = 0 ;
16668 PyObject * obj1 = 0 ;
16669 PyObject * obj2 = 0 ;
16670 char *kwnames[] = {
16671 (char *) "self",(char *) "x",(char *) "y", NULL
16672 };
16673
16674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CalcBoundingBox",kwnames,&obj0,&obj1,&obj2)) goto fail;
16675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16676 if (SWIG_arg_fail(1)) SWIG_fail;
16677 {
16678 arg2 = (int)(SWIG_As_int(obj1));
16679 if (SWIG_arg_fail(2)) SWIG_fail;
16680 }
16681 {
16682 arg3 = (int)(SWIG_As_int(obj2));
16683 if (SWIG_arg_fail(3)) SWIG_fail;
16684 }
16685 {
16686 PyThreadState* __tstate = wxPyBeginAllowThreads();
16687 (arg1)->CalcBoundingBox(arg2,arg3);
16688
16689 wxPyEndAllowThreads(__tstate);
16690 if (PyErr_Occurred()) SWIG_fail;
16691 }
16692 Py_INCREF(Py_None); resultobj = Py_None;
16693 return resultobj;
16694 fail:
16695 return NULL;
16696 }
16697
16698
16699 static PyObject *_wrap_DC_CalcBoundingBoxPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16700 PyObject *resultobj;
16701 wxDC *arg1 = (wxDC *) 0 ;
16702 wxPoint *arg2 = 0 ;
16703 wxPoint temp2 ;
16704 PyObject * obj0 = 0 ;
16705 PyObject * obj1 = 0 ;
16706 char *kwnames[] = {
16707 (char *) "self",(char *) "point", NULL
16708 };
16709
16710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CalcBoundingBoxPoint",kwnames,&obj0,&obj1)) goto fail;
16711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16712 if (SWIG_arg_fail(1)) SWIG_fail;
16713 {
16714 arg2 = &temp2;
16715 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16716 }
16717 {
16718 PyThreadState* __tstate = wxPyBeginAllowThreads();
16719 wxDC_CalcBoundingBoxPoint(arg1,(wxPoint const &)*arg2);
16720
16721 wxPyEndAllowThreads(__tstate);
16722 if (PyErr_Occurred()) SWIG_fail;
16723 }
16724 Py_INCREF(Py_None); resultobj = Py_None;
16725 return resultobj;
16726 fail:
16727 return NULL;
16728 }
16729
16730
16731 static PyObject *_wrap_DC_ResetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16732 PyObject *resultobj;
16733 wxDC *arg1 = (wxDC *) 0 ;
16734 PyObject * obj0 = 0 ;
16735 char *kwnames[] = {
16736 (char *) "self", NULL
16737 };
16738
16739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ResetBoundingBox",kwnames,&obj0)) goto fail;
16740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16741 if (SWIG_arg_fail(1)) SWIG_fail;
16742 {
16743 PyThreadState* __tstate = wxPyBeginAllowThreads();
16744 (arg1)->ResetBoundingBox();
16745
16746 wxPyEndAllowThreads(__tstate);
16747 if (PyErr_Occurred()) SWIG_fail;
16748 }
16749 Py_INCREF(Py_None); resultobj = Py_None;
16750 return resultobj;
16751 fail:
16752 return NULL;
16753 }
16754
16755
16756 static PyObject *_wrap_DC_MinX(PyObject *, PyObject *args, PyObject *kwargs) {
16757 PyObject *resultobj;
16758 wxDC *arg1 = (wxDC *) 0 ;
16759 int result;
16760 PyObject * obj0 = 0 ;
16761 char *kwnames[] = {
16762 (char *) "self", NULL
16763 };
16764
16765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinX",kwnames,&obj0)) goto fail;
16766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16767 if (SWIG_arg_fail(1)) SWIG_fail;
16768 {
16769 PyThreadState* __tstate = wxPyBeginAllowThreads();
16770 result = (int)((wxDC const *)arg1)->MinX();
16771
16772 wxPyEndAllowThreads(__tstate);
16773 if (PyErr_Occurred()) SWIG_fail;
16774 }
16775 {
16776 resultobj = SWIG_From_int((int)(result));
16777 }
16778 return resultobj;
16779 fail:
16780 return NULL;
16781 }
16782
16783
16784 static PyObject *_wrap_DC_MaxX(PyObject *, PyObject *args, PyObject *kwargs) {
16785 PyObject *resultobj;
16786 wxDC *arg1 = (wxDC *) 0 ;
16787 int result;
16788 PyObject * obj0 = 0 ;
16789 char *kwnames[] = {
16790 (char *) "self", NULL
16791 };
16792
16793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxX",kwnames,&obj0)) goto fail;
16794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16795 if (SWIG_arg_fail(1)) SWIG_fail;
16796 {
16797 PyThreadState* __tstate = wxPyBeginAllowThreads();
16798 result = (int)((wxDC const *)arg1)->MaxX();
16799
16800 wxPyEndAllowThreads(__tstate);
16801 if (PyErr_Occurred()) SWIG_fail;
16802 }
16803 {
16804 resultobj = SWIG_From_int((int)(result));
16805 }
16806 return resultobj;
16807 fail:
16808 return NULL;
16809 }
16810
16811
16812 static PyObject *_wrap_DC_MinY(PyObject *, PyObject *args, PyObject *kwargs) {
16813 PyObject *resultobj;
16814 wxDC *arg1 = (wxDC *) 0 ;
16815 int result;
16816 PyObject * obj0 = 0 ;
16817 char *kwnames[] = {
16818 (char *) "self", NULL
16819 };
16820
16821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinY",kwnames,&obj0)) goto fail;
16822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16823 if (SWIG_arg_fail(1)) SWIG_fail;
16824 {
16825 PyThreadState* __tstate = wxPyBeginAllowThreads();
16826 result = (int)((wxDC const *)arg1)->MinY();
16827
16828 wxPyEndAllowThreads(__tstate);
16829 if (PyErr_Occurred()) SWIG_fail;
16830 }
16831 {
16832 resultobj = SWIG_From_int((int)(result));
16833 }
16834 return resultobj;
16835 fail:
16836 return NULL;
16837 }
16838
16839
16840 static PyObject *_wrap_DC_MaxY(PyObject *, PyObject *args, PyObject *kwargs) {
16841 PyObject *resultobj;
16842 wxDC *arg1 = (wxDC *) 0 ;
16843 int result;
16844 PyObject * obj0 = 0 ;
16845 char *kwnames[] = {
16846 (char *) "self", NULL
16847 };
16848
16849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxY",kwnames,&obj0)) goto fail;
16850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16851 if (SWIG_arg_fail(1)) SWIG_fail;
16852 {
16853 PyThreadState* __tstate = wxPyBeginAllowThreads();
16854 result = (int)((wxDC const *)arg1)->MaxY();
16855
16856 wxPyEndAllowThreads(__tstate);
16857 if (PyErr_Occurred()) SWIG_fail;
16858 }
16859 {
16860 resultobj = SWIG_From_int((int)(result));
16861 }
16862 return resultobj;
16863 fail:
16864 return NULL;
16865 }
16866
16867
16868 static PyObject *_wrap_DC_GetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16869 PyObject *resultobj;
16870 wxDC *arg1 = (wxDC *) 0 ;
16871 int *arg2 = (int *) 0 ;
16872 int *arg3 = (int *) 0 ;
16873 int *arg4 = (int *) 0 ;
16874 int *arg5 = (int *) 0 ;
16875 int temp2 ;
16876 int res2 = 0 ;
16877 int temp3 ;
16878 int res3 = 0 ;
16879 int temp4 ;
16880 int res4 = 0 ;
16881 int temp5 ;
16882 int res5 = 0 ;
16883 PyObject * obj0 = 0 ;
16884 char *kwnames[] = {
16885 (char *) "self", NULL
16886 };
16887
16888 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16889 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16890 arg4 = &temp4; res4 = SWIG_NEWOBJ;
16891 arg5 = &temp5; res5 = SWIG_NEWOBJ;
16892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBoundingBox",kwnames,&obj0)) goto fail;
16893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16894 if (SWIG_arg_fail(1)) SWIG_fail;
16895 {
16896 PyThreadState* __tstate = wxPyBeginAllowThreads();
16897 wxDC_GetBoundingBox(arg1,arg2,arg3,arg4,arg5);
16898
16899 wxPyEndAllowThreads(__tstate);
16900 if (PyErr_Occurred()) SWIG_fail;
16901 }
16902 Py_INCREF(Py_None); resultobj = Py_None;
16903 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16904 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16905 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16906 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16907 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
16908 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
16909 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
16910 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
16911 return resultobj;
16912 fail:
16913 return NULL;
16914 }
16915
16916
16917 static PyObject *_wrap_DC__DrawPointList(PyObject *, PyObject *args, PyObject *kwargs) {
16918 PyObject *resultobj;
16919 wxDC *arg1 = (wxDC *) 0 ;
16920 PyObject *arg2 = (PyObject *) 0 ;
16921 PyObject *arg3 = (PyObject *) 0 ;
16922 PyObject *arg4 = (PyObject *) 0 ;
16923 PyObject *result;
16924 PyObject * obj0 = 0 ;
16925 PyObject * obj1 = 0 ;
16926 PyObject * obj2 = 0 ;
16927 PyObject * obj3 = 0 ;
16928 char *kwnames[] = {
16929 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
16930 };
16931
16932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPointList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16934 if (SWIG_arg_fail(1)) SWIG_fail;
16935 arg2 = obj1;
16936 arg3 = obj2;
16937 arg4 = obj3;
16938 {
16939 PyThreadState* __tstate = wxPyBeginAllowThreads();
16940 result = (PyObject *)wxDC__DrawPointList(arg1,arg2,arg3,arg4);
16941
16942 wxPyEndAllowThreads(__tstate);
16943 if (PyErr_Occurred()) SWIG_fail;
16944 }
16945 resultobj = result;
16946 return resultobj;
16947 fail:
16948 return NULL;
16949 }
16950
16951
16952 static PyObject *_wrap_DC__DrawLineList(PyObject *, PyObject *args, PyObject *kwargs) {
16953 PyObject *resultobj;
16954 wxDC *arg1 = (wxDC *) 0 ;
16955 PyObject *arg2 = (PyObject *) 0 ;
16956 PyObject *arg3 = (PyObject *) 0 ;
16957 PyObject *arg4 = (PyObject *) 0 ;
16958 PyObject *result;
16959 PyObject * obj0 = 0 ;
16960 PyObject * obj1 = 0 ;
16961 PyObject * obj2 = 0 ;
16962 PyObject * obj3 = 0 ;
16963 char *kwnames[] = {
16964 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
16965 };
16966
16967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawLineList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16969 if (SWIG_arg_fail(1)) SWIG_fail;
16970 arg2 = obj1;
16971 arg3 = obj2;
16972 arg4 = obj3;
16973 {
16974 PyThreadState* __tstate = wxPyBeginAllowThreads();
16975 result = (PyObject *)wxDC__DrawLineList(arg1,arg2,arg3,arg4);
16976
16977 wxPyEndAllowThreads(__tstate);
16978 if (PyErr_Occurred()) SWIG_fail;
16979 }
16980 resultobj = result;
16981 return resultobj;
16982 fail:
16983 return NULL;
16984 }
16985
16986
16987 static PyObject *_wrap_DC__DrawRectangleList(PyObject *, PyObject *args, PyObject *kwargs) {
16988 PyObject *resultobj;
16989 wxDC *arg1 = (wxDC *) 0 ;
16990 PyObject *arg2 = (PyObject *) 0 ;
16991 PyObject *arg3 = (PyObject *) 0 ;
16992 PyObject *arg4 = (PyObject *) 0 ;
16993 PyObject *result;
16994 PyObject * obj0 = 0 ;
16995 PyObject * obj1 = 0 ;
16996 PyObject * obj2 = 0 ;
16997 PyObject * obj3 = 0 ;
16998 char *kwnames[] = {
16999 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17000 };
17001
17002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawRectangleList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17004 if (SWIG_arg_fail(1)) SWIG_fail;
17005 arg2 = obj1;
17006 arg3 = obj2;
17007 arg4 = obj3;
17008 {
17009 PyThreadState* __tstate = wxPyBeginAllowThreads();
17010 result = (PyObject *)wxDC__DrawRectangleList(arg1,arg2,arg3,arg4);
17011
17012 wxPyEndAllowThreads(__tstate);
17013 if (PyErr_Occurred()) SWIG_fail;
17014 }
17015 resultobj = result;
17016 return resultobj;
17017 fail:
17018 return NULL;
17019 }
17020
17021
17022 static PyObject *_wrap_DC__DrawEllipseList(PyObject *, PyObject *args, PyObject *kwargs) {
17023 PyObject *resultobj;
17024 wxDC *arg1 = (wxDC *) 0 ;
17025 PyObject *arg2 = (PyObject *) 0 ;
17026 PyObject *arg3 = (PyObject *) 0 ;
17027 PyObject *arg4 = (PyObject *) 0 ;
17028 PyObject *result;
17029 PyObject * obj0 = 0 ;
17030 PyObject * obj1 = 0 ;
17031 PyObject * obj2 = 0 ;
17032 PyObject * obj3 = 0 ;
17033 char *kwnames[] = {
17034 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17035 };
17036
17037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawEllipseList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17039 if (SWIG_arg_fail(1)) SWIG_fail;
17040 arg2 = obj1;
17041 arg3 = obj2;
17042 arg4 = obj3;
17043 {
17044 PyThreadState* __tstate = wxPyBeginAllowThreads();
17045 result = (PyObject *)wxDC__DrawEllipseList(arg1,arg2,arg3,arg4);
17046
17047 wxPyEndAllowThreads(__tstate);
17048 if (PyErr_Occurred()) SWIG_fail;
17049 }
17050 resultobj = result;
17051 return resultobj;
17052 fail:
17053 return NULL;
17054 }
17055
17056
17057 static PyObject *_wrap_DC__DrawPolygonList(PyObject *, PyObject *args, PyObject *kwargs) {
17058 PyObject *resultobj;
17059 wxDC *arg1 = (wxDC *) 0 ;
17060 PyObject *arg2 = (PyObject *) 0 ;
17061 PyObject *arg3 = (PyObject *) 0 ;
17062 PyObject *arg4 = (PyObject *) 0 ;
17063 PyObject *result;
17064 PyObject * obj0 = 0 ;
17065 PyObject * obj1 = 0 ;
17066 PyObject * obj2 = 0 ;
17067 PyObject * obj3 = 0 ;
17068 char *kwnames[] = {
17069 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17070 };
17071
17072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPolygonList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17074 if (SWIG_arg_fail(1)) SWIG_fail;
17075 arg2 = obj1;
17076 arg3 = obj2;
17077 arg4 = obj3;
17078 {
17079 PyThreadState* __tstate = wxPyBeginAllowThreads();
17080 result = (PyObject *)wxDC__DrawPolygonList(arg1,arg2,arg3,arg4);
17081
17082 wxPyEndAllowThreads(__tstate);
17083 if (PyErr_Occurred()) SWIG_fail;
17084 }
17085 resultobj = result;
17086 return resultobj;
17087 fail:
17088 return NULL;
17089 }
17090
17091
17092 static PyObject *_wrap_DC__DrawTextList(PyObject *, PyObject *args, PyObject *kwargs) {
17093 PyObject *resultobj;
17094 wxDC *arg1 = (wxDC *) 0 ;
17095 PyObject *arg2 = (PyObject *) 0 ;
17096 PyObject *arg3 = (PyObject *) 0 ;
17097 PyObject *arg4 = (PyObject *) 0 ;
17098 PyObject *arg5 = (PyObject *) 0 ;
17099 PyObject *result;
17100 PyObject * obj0 = 0 ;
17101 PyObject * obj1 = 0 ;
17102 PyObject * obj2 = 0 ;
17103 PyObject * obj3 = 0 ;
17104 PyObject * obj4 = 0 ;
17105 char *kwnames[] = {
17106 (char *) "self",(char *) "textList",(char *) "pyPoints",(char *) "foregroundList",(char *) "backgroundList", NULL
17107 };
17108
17109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC__DrawTextList",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
17110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17111 if (SWIG_arg_fail(1)) SWIG_fail;
17112 arg2 = obj1;
17113 arg3 = obj2;
17114 arg4 = obj3;
17115 arg5 = obj4;
17116 {
17117 PyThreadState* __tstate = wxPyBeginAllowThreads();
17118 result = (PyObject *)wxDC__DrawTextList(arg1,arg2,arg3,arg4,arg5);
17119
17120 wxPyEndAllowThreads(__tstate);
17121 if (PyErr_Occurred()) SWIG_fail;
17122 }
17123 resultobj = result;
17124 return resultobj;
17125 fail:
17126 return NULL;
17127 }
17128
17129
17130 static PyObject * DC_swigregister(PyObject *, PyObject *args) {
17131 PyObject *obj;
17132 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17133 SWIG_TypeClientData(SWIGTYPE_p_wxDC, obj);
17134 Py_INCREF(obj);
17135 return Py_BuildValue((char *)"");
17136 }
17137 static PyObject *_wrap_new_MemoryDC(PyObject *, PyObject *args, PyObject *kwargs) {
17138 PyObject *resultobj;
17139 wxMemoryDC *result;
17140 char *kwnames[] = {
17141 NULL
17142 };
17143
17144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryDC",kwnames)) goto fail;
17145 {
17146 if (!wxPyCheckForApp()) SWIG_fail;
17147 PyThreadState* __tstate = wxPyBeginAllowThreads();
17148 result = (wxMemoryDC *)new wxMemoryDC();
17149
17150 wxPyEndAllowThreads(__tstate);
17151 if (PyErr_Occurred()) SWIG_fail;
17152 }
17153 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17154 return resultobj;
17155 fail:
17156 return NULL;
17157 }
17158
17159
17160 static PyObject *_wrap_new_MemoryDCFromDC(PyObject *, PyObject *args, PyObject *kwargs) {
17161 PyObject *resultobj;
17162 wxDC *arg1 = (wxDC *) 0 ;
17163 wxMemoryDC *result;
17164 PyObject * obj0 = 0 ;
17165 char *kwnames[] = {
17166 (char *) "oldDC", NULL
17167 };
17168
17169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_MemoryDCFromDC",kwnames,&obj0)) goto fail;
17170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17171 if (SWIG_arg_fail(1)) SWIG_fail;
17172 {
17173 if (!wxPyCheckForApp()) SWIG_fail;
17174 PyThreadState* __tstate = wxPyBeginAllowThreads();
17175 result = (wxMemoryDC *)new wxMemoryDC(arg1);
17176
17177 wxPyEndAllowThreads(__tstate);
17178 if (PyErr_Occurred()) SWIG_fail;
17179 }
17180 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17181 return resultobj;
17182 fail:
17183 return NULL;
17184 }
17185
17186
17187 static PyObject *_wrap_MemoryDC_SelectObject(PyObject *, PyObject *args, PyObject *kwargs) {
17188 PyObject *resultobj;
17189 wxMemoryDC *arg1 = (wxMemoryDC *) 0 ;
17190 wxBitmap *arg2 = 0 ;
17191 PyObject * obj0 = 0 ;
17192 PyObject * obj1 = 0 ;
17193 char *kwnames[] = {
17194 (char *) "self",(char *) "bitmap", NULL
17195 };
17196
17197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryDC_SelectObject",kwnames,&obj0,&obj1)) goto fail;
17198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_EXCEPTION | 0);
17199 if (SWIG_arg_fail(1)) SWIG_fail;
17200 {
17201 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17202 if (SWIG_arg_fail(2)) SWIG_fail;
17203 if (arg2 == NULL) {
17204 SWIG_null_ref("wxBitmap");
17205 }
17206 if (SWIG_arg_fail(2)) SWIG_fail;
17207 }
17208 {
17209 PyThreadState* __tstate = wxPyBeginAllowThreads();
17210 (arg1)->SelectObject((wxBitmap const &)*arg2);
17211
17212 wxPyEndAllowThreads(__tstate);
17213 if (PyErr_Occurred()) SWIG_fail;
17214 }
17215 Py_INCREF(Py_None); resultobj = Py_None;
17216 return resultobj;
17217 fail:
17218 return NULL;
17219 }
17220
17221
17222 static PyObject * MemoryDC_swigregister(PyObject *, PyObject *args) {
17223 PyObject *obj;
17224 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17225 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryDC, obj);
17226 Py_INCREF(obj);
17227 return Py_BuildValue((char *)"");
17228 }
17229 static PyObject *_wrap_new_BufferedDC__SWIG_0(PyObject *, PyObject *args) {
17230 PyObject *resultobj;
17231 wxDC *arg1 = (wxDC *) 0 ;
17232 wxBitmap *arg2 = 0 ;
17233 wxBufferedDC *result;
17234 PyObject * obj0 = 0 ;
17235 PyObject * obj1 = 0 ;
17236
17237 if(!PyArg_ParseTuple(args,(char *)"OO:new_BufferedDC",&obj0,&obj1)) goto fail;
17238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17239 if (SWIG_arg_fail(1)) SWIG_fail;
17240 {
17241 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17242 if (SWIG_arg_fail(2)) SWIG_fail;
17243 if (arg2 == NULL) {
17244 SWIG_null_ref("wxBitmap");
17245 }
17246 if (SWIG_arg_fail(2)) SWIG_fail;
17247 }
17248 {
17249 if (!wxPyCheckForApp()) SWIG_fail;
17250 PyThreadState* __tstate = wxPyBeginAllowThreads();
17251 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxBitmap const &)*arg2);
17252
17253 wxPyEndAllowThreads(__tstate);
17254 if (PyErr_Occurred()) SWIG_fail;
17255 }
17256 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17257 return resultobj;
17258 fail:
17259 return NULL;
17260 }
17261
17262
17263 static PyObject *_wrap_new_BufferedDC__SWIG_1(PyObject *, PyObject *args) {
17264 PyObject *resultobj;
17265 wxDC *arg1 = (wxDC *) 0 ;
17266 wxSize *arg2 = 0 ;
17267 wxBufferedDC *result;
17268 wxSize temp2 ;
17269 PyObject * obj0 = 0 ;
17270 PyObject * obj1 = 0 ;
17271
17272 if(!PyArg_ParseTuple(args,(char *)"OO:new_BufferedDC",&obj0,&obj1)) goto fail;
17273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17274 if (SWIG_arg_fail(1)) SWIG_fail;
17275 {
17276 arg2 = &temp2;
17277 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17278 }
17279 {
17280 if (!wxPyCheckForApp()) SWIG_fail;
17281 PyThreadState* __tstate = wxPyBeginAllowThreads();
17282 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxSize const &)*arg2);
17283
17284 wxPyEndAllowThreads(__tstate);
17285 if (PyErr_Occurred()) SWIG_fail;
17286 }
17287 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17288 return resultobj;
17289 fail:
17290 return NULL;
17291 }
17292
17293
17294 static PyObject *_wrap_new_BufferedDC(PyObject *self, PyObject *args) {
17295 int argc;
17296 PyObject *argv[3];
17297 int ii;
17298
17299 argc = PyObject_Length(args);
17300 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
17301 argv[ii] = PyTuple_GetItem(args,ii);
17302 }
17303 if (argc == 2) {
17304 int _v;
17305 {
17306 void *ptr;
17307 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
17308 _v = 0;
17309 PyErr_Clear();
17310 } else {
17311 _v = 1;
17312 }
17313 }
17314 if (_v) {
17315 {
17316 void *ptr = 0;
17317 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxBitmap, 0) == -1) {
17318 _v = 0;
17319 PyErr_Clear();
17320 } else {
17321 _v = (ptr != 0);
17322 }
17323 }
17324 if (_v) {
17325 return _wrap_new_BufferedDC__SWIG_0(self,args);
17326 }
17327 }
17328 }
17329 if (argc == 2) {
17330 int _v;
17331 {
17332 void *ptr;
17333 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
17334 _v = 0;
17335 PyErr_Clear();
17336 } else {
17337 _v = 1;
17338 }
17339 }
17340 if (_v) {
17341 {
17342 _v = wxPySimple_typecheck(argv[1], wxT("wxSize"), 2);
17343 }
17344 if (_v) {
17345 return _wrap_new_BufferedDC__SWIG_1(self,args);
17346 }
17347 }
17348 }
17349
17350 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_BufferedDC'");
17351 return NULL;
17352 }
17353
17354
17355 static PyObject *_wrap_delete_BufferedDC(PyObject *, PyObject *args, PyObject *kwargs) {
17356 PyObject *resultobj;
17357 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
17358 PyObject * obj0 = 0 ;
17359 char *kwnames[] = {
17360 (char *) "self", NULL
17361 };
17362
17363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BufferedDC",kwnames,&obj0)) goto fail;
17364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
17365 if (SWIG_arg_fail(1)) SWIG_fail;
17366 {
17367 PyThreadState* __tstate = wxPyBeginAllowThreads();
17368 delete arg1;
17369
17370 wxPyEndAllowThreads(__tstate);
17371 if (PyErr_Occurred()) SWIG_fail;
17372 }
17373 Py_INCREF(Py_None); resultobj = Py_None;
17374 return resultobj;
17375 fail:
17376 return NULL;
17377 }
17378
17379
17380 static PyObject *_wrap_BufferedDC_UnMask(PyObject *, PyObject *args, PyObject *kwargs) {
17381 PyObject *resultobj;
17382 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
17383 PyObject * obj0 = 0 ;
17384 char *kwnames[] = {
17385 (char *) "self", NULL
17386 };
17387
17388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BufferedDC_UnMask",kwnames,&obj0)) goto fail;
17389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
17390 if (SWIG_arg_fail(1)) SWIG_fail;
17391 {
17392 PyThreadState* __tstate = wxPyBeginAllowThreads();
17393 (arg1)->UnMask();
17394
17395 wxPyEndAllowThreads(__tstate);
17396 if (PyErr_Occurred()) SWIG_fail;
17397 }
17398 Py_INCREF(Py_None); resultobj = Py_None;
17399 return resultobj;
17400 fail:
17401 return NULL;
17402 }
17403
17404
17405 static PyObject * BufferedDC_swigregister(PyObject *, PyObject *args) {
17406 PyObject *obj;
17407 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17408 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedDC, obj);
17409 Py_INCREF(obj);
17410 return Py_BuildValue((char *)"");
17411 }
17412 static PyObject *_wrap_new_BufferedPaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
17413 PyObject *resultobj;
17414 wxWindow *arg1 = (wxWindow *) 0 ;
17415 wxBitmap const &arg2_defvalue = wxNullBitmap ;
17416 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
17417 wxBufferedPaintDC *result;
17418 PyObject * obj0 = 0 ;
17419 PyObject * obj1 = 0 ;
17420 char *kwnames[] = {
17421 (char *) "window",(char *) "buffer", NULL
17422 };
17423
17424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BufferedPaintDC",kwnames,&obj0,&obj1)) goto fail;
17425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17426 if (SWIG_arg_fail(1)) SWIG_fail;
17427 if (obj1) {
17428 {
17429 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17430 if (SWIG_arg_fail(2)) SWIG_fail;
17431 if (arg2 == NULL) {
17432 SWIG_null_ref("wxBitmap");
17433 }
17434 if (SWIG_arg_fail(2)) SWIG_fail;
17435 }
17436 }
17437 {
17438 if (!wxPyCheckForApp()) SWIG_fail;
17439 PyThreadState* __tstate = wxPyBeginAllowThreads();
17440 result = (wxBufferedPaintDC *)new wxBufferedPaintDC(arg1,(wxBitmap const &)*arg2);
17441
17442 wxPyEndAllowThreads(__tstate);
17443 if (PyErr_Occurred()) SWIG_fail;
17444 }
17445 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedPaintDC, 1);
17446 return resultobj;
17447 fail:
17448 return NULL;
17449 }
17450
17451
17452 static PyObject * BufferedPaintDC_swigregister(PyObject *, PyObject *args) {
17453 PyObject *obj;
17454 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17455 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedPaintDC, obj);
17456 Py_INCREF(obj);
17457 return Py_BuildValue((char *)"");
17458 }
17459 static PyObject *_wrap_new_ScreenDC(PyObject *, PyObject *args, PyObject *kwargs) {
17460 PyObject *resultobj;
17461 wxScreenDC *result;
17462 char *kwnames[] = {
17463 NULL
17464 };
17465
17466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ScreenDC",kwnames)) goto fail;
17467 {
17468 if (!wxPyCheckForApp()) SWIG_fail;
17469 PyThreadState* __tstate = wxPyBeginAllowThreads();
17470 result = (wxScreenDC *)new wxScreenDC();
17471
17472 wxPyEndAllowThreads(__tstate);
17473 if (PyErr_Occurred()) SWIG_fail;
17474 }
17475 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScreenDC, 1);
17476 return resultobj;
17477 fail:
17478 return NULL;
17479 }
17480
17481
17482 static PyObject *_wrap_ScreenDC_StartDrawingOnTopWin(PyObject *, PyObject *args, PyObject *kwargs) {
17483 PyObject *resultobj;
17484 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17485 wxWindow *arg2 = (wxWindow *) 0 ;
17486 bool result;
17487 PyObject * obj0 = 0 ;
17488 PyObject * obj1 = 0 ;
17489 char *kwnames[] = {
17490 (char *) "self",(char *) "window", NULL
17491 };
17492
17493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScreenDC_StartDrawingOnTopWin",kwnames,&obj0,&obj1)) goto fail;
17494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17495 if (SWIG_arg_fail(1)) SWIG_fail;
17496 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17497 if (SWIG_arg_fail(2)) SWIG_fail;
17498 {
17499 PyThreadState* __tstate = wxPyBeginAllowThreads();
17500 result = (bool)(arg1)->StartDrawingOnTop(arg2);
17501
17502 wxPyEndAllowThreads(__tstate);
17503 if (PyErr_Occurred()) SWIG_fail;
17504 }
17505 {
17506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17507 }
17508 return resultobj;
17509 fail:
17510 return NULL;
17511 }
17512
17513
17514 static PyObject *_wrap_ScreenDC_StartDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
17515 PyObject *resultobj;
17516 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17517 wxRect *arg2 = (wxRect *) NULL ;
17518 bool result;
17519 PyObject * obj0 = 0 ;
17520 PyObject * obj1 = 0 ;
17521 char *kwnames[] = {
17522 (char *) "self",(char *) "rect", NULL
17523 };
17524
17525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ScreenDC_StartDrawingOnTop",kwnames,&obj0,&obj1)) goto fail;
17526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17527 if (SWIG_arg_fail(1)) SWIG_fail;
17528 if (obj1) {
17529 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
17530 if (SWIG_arg_fail(2)) SWIG_fail;
17531 }
17532 {
17533 PyThreadState* __tstate = wxPyBeginAllowThreads();
17534 result = (bool)(arg1)->StartDrawingOnTop(arg2);
17535
17536 wxPyEndAllowThreads(__tstate);
17537 if (PyErr_Occurred()) SWIG_fail;
17538 }
17539 {
17540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17541 }
17542 return resultobj;
17543 fail:
17544 return NULL;
17545 }
17546
17547
17548 static PyObject *_wrap_ScreenDC_EndDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
17549 PyObject *resultobj;
17550 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17551 bool result;
17552 PyObject * obj0 = 0 ;
17553 char *kwnames[] = {
17554 (char *) "self", NULL
17555 };
17556
17557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScreenDC_EndDrawingOnTop",kwnames,&obj0)) goto fail;
17558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17559 if (SWIG_arg_fail(1)) SWIG_fail;
17560 {
17561 PyThreadState* __tstate = wxPyBeginAllowThreads();
17562 result = (bool)(arg1)->EndDrawingOnTop();
17563
17564 wxPyEndAllowThreads(__tstate);
17565 if (PyErr_Occurred()) SWIG_fail;
17566 }
17567 {
17568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17569 }
17570 return resultobj;
17571 fail:
17572 return NULL;
17573 }
17574
17575
17576 static PyObject * ScreenDC_swigregister(PyObject *, PyObject *args) {
17577 PyObject *obj;
17578 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17579 SWIG_TypeClientData(SWIGTYPE_p_wxScreenDC, obj);
17580 Py_INCREF(obj);
17581 return Py_BuildValue((char *)"");
17582 }
17583 static PyObject *_wrap_new_ClientDC(PyObject *, PyObject *args, PyObject *kwargs) {
17584 PyObject *resultobj;
17585 wxWindow *arg1 = (wxWindow *) 0 ;
17586 wxClientDC *result;
17587 PyObject * obj0 = 0 ;
17588 char *kwnames[] = {
17589 (char *) "win", NULL
17590 };
17591
17592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ClientDC",kwnames,&obj0)) goto fail;
17593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17594 if (SWIG_arg_fail(1)) SWIG_fail;
17595 {
17596 if (!wxPyCheckForApp()) SWIG_fail;
17597 PyThreadState* __tstate = wxPyBeginAllowThreads();
17598 result = (wxClientDC *)new wxClientDC(arg1);
17599
17600 wxPyEndAllowThreads(__tstate);
17601 if (PyErr_Occurred()) SWIG_fail;
17602 }
17603 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClientDC, 1);
17604 return resultobj;
17605 fail:
17606 return NULL;
17607 }
17608
17609
17610 static PyObject * ClientDC_swigregister(PyObject *, PyObject *args) {
17611 PyObject *obj;
17612 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17613 SWIG_TypeClientData(SWIGTYPE_p_wxClientDC, obj);
17614 Py_INCREF(obj);
17615 return Py_BuildValue((char *)"");
17616 }
17617 static PyObject *_wrap_new_PaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
17618 PyObject *resultobj;
17619 wxWindow *arg1 = (wxWindow *) 0 ;
17620 wxPaintDC *result;
17621 PyObject * obj0 = 0 ;
17622 char *kwnames[] = {
17623 (char *) "win", NULL
17624 };
17625
17626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PaintDC",kwnames,&obj0)) goto fail;
17627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17628 if (SWIG_arg_fail(1)) SWIG_fail;
17629 {
17630 if (!wxPyCheckForApp()) SWIG_fail;
17631 PyThreadState* __tstate = wxPyBeginAllowThreads();
17632 result = (wxPaintDC *)new wxPaintDC(arg1);
17633
17634 wxPyEndAllowThreads(__tstate);
17635 if (PyErr_Occurred()) SWIG_fail;
17636 }
17637 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintDC, 1);
17638 return resultobj;
17639 fail:
17640 return NULL;
17641 }
17642
17643
17644 static PyObject * PaintDC_swigregister(PyObject *, PyObject *args) {
17645 PyObject *obj;
17646 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17647 SWIG_TypeClientData(SWIGTYPE_p_wxPaintDC, obj);
17648 Py_INCREF(obj);
17649 return Py_BuildValue((char *)"");
17650 }
17651 static PyObject *_wrap_new_WindowDC(PyObject *, PyObject *args, PyObject *kwargs) {
17652 PyObject *resultobj;
17653 wxWindow *arg1 = (wxWindow *) 0 ;
17654 wxWindowDC *result;
17655 PyObject * obj0 = 0 ;
17656 char *kwnames[] = {
17657 (char *) "win", NULL
17658 };
17659
17660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_WindowDC",kwnames,&obj0)) goto fail;
17661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17662 if (SWIG_arg_fail(1)) SWIG_fail;
17663 {
17664 if (!wxPyCheckForApp()) SWIG_fail;
17665 PyThreadState* __tstate = wxPyBeginAllowThreads();
17666 result = (wxWindowDC *)new wxWindowDC(arg1);
17667
17668 wxPyEndAllowThreads(__tstate);
17669 if (PyErr_Occurred()) SWIG_fail;
17670 }
17671 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDC, 1);
17672 return resultobj;
17673 fail:
17674 return NULL;
17675 }
17676
17677
17678 static PyObject * WindowDC_swigregister(PyObject *, PyObject *args) {
17679 PyObject *obj;
17680 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17681 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDC, obj);
17682 Py_INCREF(obj);
17683 return Py_BuildValue((char *)"");
17684 }
17685 static PyObject *_wrap_new_MirrorDC(PyObject *, PyObject *args, PyObject *kwargs) {
17686 PyObject *resultobj;
17687 wxDC *arg1 = 0 ;
17688 bool arg2 ;
17689 wxMirrorDC *result;
17690 PyObject * obj0 = 0 ;
17691 PyObject * obj1 = 0 ;
17692 char *kwnames[] = {
17693 (char *) "dc",(char *) "mirror", NULL
17694 };
17695
17696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_MirrorDC",kwnames,&obj0,&obj1)) goto fail;
17697 {
17698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17699 if (SWIG_arg_fail(1)) SWIG_fail;
17700 if (arg1 == NULL) {
17701 SWIG_null_ref("wxDC");
17702 }
17703 if (SWIG_arg_fail(1)) SWIG_fail;
17704 }
17705 {
17706 arg2 = (bool)(SWIG_As_bool(obj1));
17707 if (SWIG_arg_fail(2)) SWIG_fail;
17708 }
17709 {
17710 if (!wxPyCheckForApp()) SWIG_fail;
17711 PyThreadState* __tstate = wxPyBeginAllowThreads();
17712 result = (wxMirrorDC *)new wxMirrorDC(*arg1,arg2);
17713
17714 wxPyEndAllowThreads(__tstate);
17715 if (PyErr_Occurred()) SWIG_fail;
17716 }
17717 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMirrorDC, 1);
17718 return resultobj;
17719 fail:
17720 return NULL;
17721 }
17722
17723
17724 static PyObject * MirrorDC_swigregister(PyObject *, PyObject *args) {
17725 PyObject *obj;
17726 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17727 SWIG_TypeClientData(SWIGTYPE_p_wxMirrorDC, obj);
17728 Py_INCREF(obj);
17729 return Py_BuildValue((char *)"");
17730 }
17731 static PyObject *_wrap_new_PostScriptDC(PyObject *, PyObject *args, PyObject *kwargs) {
17732 PyObject *resultobj;
17733 wxPrintData *arg1 = 0 ;
17734 wxPostScriptDC *result;
17735 PyObject * obj0 = 0 ;
17736 char *kwnames[] = {
17737 (char *) "printData", NULL
17738 };
17739
17740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PostScriptDC",kwnames,&obj0)) goto fail;
17741 {
17742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
17743 if (SWIG_arg_fail(1)) SWIG_fail;
17744 if (arg1 == NULL) {
17745 SWIG_null_ref("wxPrintData");
17746 }
17747 if (SWIG_arg_fail(1)) SWIG_fail;
17748 }
17749 {
17750 if (!wxPyCheckForApp()) SWIG_fail;
17751 PyThreadState* __tstate = wxPyBeginAllowThreads();
17752 result = (wxPostScriptDC *)new wxPostScriptDC((wxPrintData const &)*arg1);
17753
17754 wxPyEndAllowThreads(__tstate);
17755 if (PyErr_Occurred()) SWIG_fail;
17756 }
17757 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPostScriptDC, 1);
17758 return resultobj;
17759 fail:
17760 return NULL;
17761 }
17762
17763
17764 static PyObject *_wrap_PostScriptDC_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
17765 PyObject *resultobj;
17766 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
17767 wxPrintData *result;
17768 PyObject * obj0 = 0 ;
17769 char *kwnames[] = {
17770 (char *) "self", NULL
17771 };
17772
17773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_GetPrintData",kwnames,&obj0)) goto fail;
17774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
17775 if (SWIG_arg_fail(1)) SWIG_fail;
17776 {
17777 PyThreadState* __tstate = wxPyBeginAllowThreads();
17778 {
17779 wxPrintData &_result_ref = (arg1)->GetPrintData();
17780 result = (wxPrintData *) &_result_ref;
17781 }
17782
17783 wxPyEndAllowThreads(__tstate);
17784 if (PyErr_Occurred()) SWIG_fail;
17785 }
17786 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
17787 return resultobj;
17788 fail:
17789 return NULL;
17790 }
17791
17792
17793 static PyObject *_wrap_PostScriptDC_SetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
17794 PyObject *resultobj;
17795 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
17796 wxPrintData *arg2 = 0 ;
17797 PyObject * obj0 = 0 ;
17798 PyObject * obj1 = 0 ;
17799 char *kwnames[] = {
17800 (char *) "self",(char *) "data", NULL
17801 };
17802
17803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostScriptDC_SetPrintData",kwnames,&obj0,&obj1)) goto fail;
17804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
17805 if (SWIG_arg_fail(1)) SWIG_fail;
17806 {
17807 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
17808 if (SWIG_arg_fail(2)) SWIG_fail;
17809 if (arg2 == NULL) {
17810 SWIG_null_ref("wxPrintData");
17811 }
17812 if (SWIG_arg_fail(2)) SWIG_fail;
17813 }
17814 {
17815 PyThreadState* __tstate = wxPyBeginAllowThreads();
17816 (arg1)->SetPrintData((wxPrintData const &)*arg2);
17817
17818 wxPyEndAllowThreads(__tstate);
17819 if (PyErr_Occurred()) SWIG_fail;
17820 }
17821 Py_INCREF(Py_None); resultobj = Py_None;
17822 return resultobj;
17823 fail:
17824 return NULL;
17825 }
17826
17827
17828 static PyObject *_wrap_PostScriptDC_SetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
17829 PyObject *resultobj;
17830 int arg1 ;
17831 PyObject * obj0 = 0 ;
17832 char *kwnames[] = {
17833 (char *) "ppi", NULL
17834 };
17835
17836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_SetResolution",kwnames,&obj0)) goto fail;
17837 {
17838 arg1 = (int)(SWIG_As_int(obj0));
17839 if (SWIG_arg_fail(1)) SWIG_fail;
17840 }
17841 {
17842 PyThreadState* __tstate = wxPyBeginAllowThreads();
17843 wxPostScriptDC::SetResolution(arg1);
17844
17845 wxPyEndAllowThreads(__tstate);
17846 if (PyErr_Occurred()) SWIG_fail;
17847 }
17848 Py_INCREF(Py_None); resultobj = Py_None;
17849 return resultobj;
17850 fail:
17851 return NULL;
17852 }
17853
17854
17855 static PyObject *_wrap_PostScriptDC_GetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
17856 PyObject *resultobj;
17857 int result;
17858 char *kwnames[] = {
17859 NULL
17860 };
17861
17862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PostScriptDC_GetResolution",kwnames)) goto fail;
17863 {
17864 PyThreadState* __tstate = wxPyBeginAllowThreads();
17865 result = (int)wxPostScriptDC::GetResolution();
17866
17867 wxPyEndAllowThreads(__tstate);
17868 if (PyErr_Occurred()) SWIG_fail;
17869 }
17870 {
17871 resultobj = SWIG_From_int((int)(result));
17872 }
17873 return resultobj;
17874 fail:
17875 return NULL;
17876 }
17877
17878
17879 static PyObject * PostScriptDC_swigregister(PyObject *, PyObject *args) {
17880 PyObject *obj;
17881 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17882 SWIG_TypeClientData(SWIGTYPE_p_wxPostScriptDC, obj);
17883 Py_INCREF(obj);
17884 return Py_BuildValue((char *)"");
17885 }
17886 static PyObject *_wrap_new_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
17887 PyObject *resultobj;
17888 wxString const &arg1_defvalue = wxPyEmptyString ;
17889 wxString *arg1 = (wxString *) &arg1_defvalue ;
17890 wxMetaFile *result;
17891 bool temp1 = false ;
17892 PyObject * obj0 = 0 ;
17893 char *kwnames[] = {
17894 (char *) "filename", NULL
17895 };
17896
17897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MetaFile",kwnames,&obj0)) goto fail;
17898 if (obj0) {
17899 {
17900 arg1 = wxString_in_helper(obj0);
17901 if (arg1 == NULL) SWIG_fail;
17902 temp1 = true;
17903 }
17904 }
17905 {
17906 if (!wxPyCheckForApp()) SWIG_fail;
17907 PyThreadState* __tstate = wxPyBeginAllowThreads();
17908 result = (wxMetaFile *)new wxMetaFile((wxString const &)*arg1);
17909
17910 wxPyEndAllowThreads(__tstate);
17911 if (PyErr_Occurred()) SWIG_fail;
17912 }
17913 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 1);
17914 {
17915 if (temp1)
17916 delete arg1;
17917 }
17918 return resultobj;
17919 fail:
17920 {
17921 if (temp1)
17922 delete arg1;
17923 }
17924 return NULL;
17925 }
17926
17927
17928 static PyObject *_wrap_delete_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
17929 PyObject *resultobj;
17930 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
17931 PyObject * obj0 = 0 ;
17932 char *kwnames[] = {
17933 (char *) "self", NULL
17934 };
17935
17936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MetaFile",kwnames,&obj0)) goto fail;
17937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
17938 if (SWIG_arg_fail(1)) SWIG_fail;
17939 {
17940 PyThreadState* __tstate = wxPyBeginAllowThreads();
17941 delete arg1;
17942
17943 wxPyEndAllowThreads(__tstate);
17944 if (PyErr_Occurred()) SWIG_fail;
17945 }
17946 Py_INCREF(Py_None); resultobj = Py_None;
17947 return resultobj;
17948 fail:
17949 return NULL;
17950 }
17951
17952
17953 static PyObject *_wrap_MetaFile_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
17954 PyObject *resultobj;
17955 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
17956 bool result;
17957 PyObject * obj0 = 0 ;
17958 char *kwnames[] = {
17959 (char *) "self", NULL
17960 };
17961
17962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_Ok",kwnames,&obj0)) goto fail;
17963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
17964 if (SWIG_arg_fail(1)) SWIG_fail;
17965 {
17966 PyThreadState* __tstate = wxPyBeginAllowThreads();
17967 result = (bool)(arg1)->Ok();
17968
17969 wxPyEndAllowThreads(__tstate);
17970 if (PyErr_Occurred()) SWIG_fail;
17971 }
17972 {
17973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17974 }
17975 return resultobj;
17976 fail:
17977 return NULL;
17978 }
17979
17980
17981 static PyObject *_wrap_MetaFile_SetClipboard(PyObject *, PyObject *args, PyObject *kwargs) {
17982 PyObject *resultobj;
17983 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
17984 int arg2 = (int) 0 ;
17985 int arg3 = (int) 0 ;
17986 bool result;
17987 PyObject * obj0 = 0 ;
17988 PyObject * obj1 = 0 ;
17989 PyObject * obj2 = 0 ;
17990 char *kwnames[] = {
17991 (char *) "self",(char *) "width",(char *) "height", NULL
17992 };
17993
17994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MetaFile_SetClipboard",kwnames,&obj0,&obj1,&obj2)) goto fail;
17995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
17996 if (SWIG_arg_fail(1)) SWIG_fail;
17997 if (obj1) {
17998 {
17999 arg2 = (int)(SWIG_As_int(obj1));
18000 if (SWIG_arg_fail(2)) SWIG_fail;
18001 }
18002 }
18003 if (obj2) {
18004 {
18005 arg3 = (int)(SWIG_As_int(obj2));
18006 if (SWIG_arg_fail(3)) SWIG_fail;
18007 }
18008 }
18009 {
18010 PyThreadState* __tstate = wxPyBeginAllowThreads();
18011 result = (bool)(arg1)->SetClipboard(arg2,arg3);
18012
18013 wxPyEndAllowThreads(__tstate);
18014 if (PyErr_Occurred()) SWIG_fail;
18015 }
18016 {
18017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18018 }
18019 return resultobj;
18020 fail:
18021 return NULL;
18022 }
18023
18024
18025 static PyObject *_wrap_MetaFile_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18026 PyObject *resultobj;
18027 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18028 wxSize result;
18029 PyObject * obj0 = 0 ;
18030 char *kwnames[] = {
18031 (char *) "self", NULL
18032 };
18033
18034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetSize",kwnames,&obj0)) goto fail;
18035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18036 if (SWIG_arg_fail(1)) SWIG_fail;
18037 {
18038 PyThreadState* __tstate = wxPyBeginAllowThreads();
18039 result = (arg1)->GetSize();
18040
18041 wxPyEndAllowThreads(__tstate);
18042 if (PyErr_Occurred()) SWIG_fail;
18043 }
18044 {
18045 wxSize * resultptr;
18046 resultptr = new wxSize((wxSize &)(result));
18047 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18048 }
18049 return resultobj;
18050 fail:
18051 return NULL;
18052 }
18053
18054
18055 static PyObject *_wrap_MetaFile_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
18056 PyObject *resultobj;
18057 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18058 int result;
18059 PyObject * obj0 = 0 ;
18060 char *kwnames[] = {
18061 (char *) "self", NULL
18062 };
18063
18064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetWidth",kwnames,&obj0)) goto fail;
18065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18066 if (SWIG_arg_fail(1)) SWIG_fail;
18067 {
18068 PyThreadState* __tstate = wxPyBeginAllowThreads();
18069 result = (int)(arg1)->GetWidth();
18070
18071 wxPyEndAllowThreads(__tstate);
18072 if (PyErr_Occurred()) SWIG_fail;
18073 }
18074 {
18075 resultobj = SWIG_From_int((int)(result));
18076 }
18077 return resultobj;
18078 fail:
18079 return NULL;
18080 }
18081
18082
18083 static PyObject *_wrap_MetaFile_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
18084 PyObject *resultobj;
18085 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18086 int result;
18087 PyObject * obj0 = 0 ;
18088 char *kwnames[] = {
18089 (char *) "self", NULL
18090 };
18091
18092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetHeight",kwnames,&obj0)) goto fail;
18093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18094 if (SWIG_arg_fail(1)) SWIG_fail;
18095 {
18096 PyThreadState* __tstate = wxPyBeginAllowThreads();
18097 result = (int)(arg1)->GetHeight();
18098
18099 wxPyEndAllowThreads(__tstate);
18100 if (PyErr_Occurred()) SWIG_fail;
18101 }
18102 {
18103 resultobj = SWIG_From_int((int)(result));
18104 }
18105 return resultobj;
18106 fail:
18107 return NULL;
18108 }
18109
18110
18111 static PyObject * MetaFile_swigregister(PyObject *, PyObject *args) {
18112 PyObject *obj;
18113 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18114 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFile, obj);
18115 Py_INCREF(obj);
18116 return Py_BuildValue((char *)"");
18117 }
18118 static PyObject *_wrap_new_MetaFileDC(PyObject *, PyObject *args, PyObject *kwargs) {
18119 PyObject *resultobj;
18120 wxString const &arg1_defvalue = wxPyEmptyString ;
18121 wxString *arg1 = (wxString *) &arg1_defvalue ;
18122 int arg2 = (int) 0 ;
18123 int arg3 = (int) 0 ;
18124 wxString const &arg4_defvalue = wxPyEmptyString ;
18125 wxString *arg4 = (wxString *) &arg4_defvalue ;
18126 wxMetaFileDC *result;
18127 bool temp1 = false ;
18128 bool temp4 = false ;
18129 PyObject * obj0 = 0 ;
18130 PyObject * obj1 = 0 ;
18131 PyObject * obj2 = 0 ;
18132 PyObject * obj3 = 0 ;
18133 char *kwnames[] = {
18134 (char *) "filename",(char *) "width",(char *) "height",(char *) "description", NULL
18135 };
18136
18137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_MetaFileDC",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18138 if (obj0) {
18139 {
18140 arg1 = wxString_in_helper(obj0);
18141 if (arg1 == NULL) SWIG_fail;
18142 temp1 = true;
18143 }
18144 }
18145 if (obj1) {
18146 {
18147 arg2 = (int)(SWIG_As_int(obj1));
18148 if (SWIG_arg_fail(2)) SWIG_fail;
18149 }
18150 }
18151 if (obj2) {
18152 {
18153 arg3 = (int)(SWIG_As_int(obj2));
18154 if (SWIG_arg_fail(3)) SWIG_fail;
18155 }
18156 }
18157 if (obj3) {
18158 {
18159 arg4 = wxString_in_helper(obj3);
18160 if (arg4 == NULL) SWIG_fail;
18161 temp4 = true;
18162 }
18163 }
18164 {
18165 if (!wxPyCheckForApp()) SWIG_fail;
18166 PyThreadState* __tstate = wxPyBeginAllowThreads();
18167 result = (wxMetaFileDC *)new wxMetaFileDC((wxString const &)*arg1,arg2,arg3,(wxString const &)*arg4);
18168
18169 wxPyEndAllowThreads(__tstate);
18170 if (PyErr_Occurred()) SWIG_fail;
18171 }
18172 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFileDC, 1);
18173 {
18174 if (temp1)
18175 delete arg1;
18176 }
18177 {
18178 if (temp4)
18179 delete arg4;
18180 }
18181 return resultobj;
18182 fail:
18183 {
18184 if (temp1)
18185 delete arg1;
18186 }
18187 {
18188 if (temp4)
18189 delete arg4;
18190 }
18191 return NULL;
18192 }
18193
18194
18195 static PyObject *_wrap_MetaFileDC_Close(PyObject *, PyObject *args, PyObject *kwargs) {
18196 PyObject *resultobj;
18197 wxMetaFileDC *arg1 = (wxMetaFileDC *) 0 ;
18198 wxMetaFile *result;
18199 PyObject * obj0 = 0 ;
18200 char *kwnames[] = {
18201 (char *) "self", NULL
18202 };
18203
18204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFileDC_Close",kwnames,&obj0)) goto fail;
18205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFileDC, SWIG_POINTER_EXCEPTION | 0);
18206 if (SWIG_arg_fail(1)) SWIG_fail;
18207 {
18208 PyThreadState* __tstate = wxPyBeginAllowThreads();
18209 result = (wxMetaFile *)(arg1)->Close();
18210
18211 wxPyEndAllowThreads(__tstate);
18212 if (PyErr_Occurred()) SWIG_fail;
18213 }
18214 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 0);
18215 return resultobj;
18216 fail:
18217 return NULL;
18218 }
18219
18220
18221 static PyObject * MetaFileDC_swigregister(PyObject *, PyObject *args) {
18222 PyObject *obj;
18223 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18224 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFileDC, obj);
18225 Py_INCREF(obj);
18226 return Py_BuildValue((char *)"");
18227 }
18228 static PyObject *_wrap_new_PrinterDC(PyObject *, PyObject *args, PyObject *kwargs) {
18229 PyObject *resultobj;
18230 wxPrintData *arg1 = 0 ;
18231 wxPrinterDC *result;
18232 PyObject * obj0 = 0 ;
18233 char *kwnames[] = {
18234 (char *) "printData", NULL
18235 };
18236
18237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PrinterDC",kwnames,&obj0)) goto fail;
18238 {
18239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18240 if (SWIG_arg_fail(1)) SWIG_fail;
18241 if (arg1 == NULL) {
18242 SWIG_null_ref("wxPrintData");
18243 }
18244 if (SWIG_arg_fail(1)) SWIG_fail;
18245 }
18246 {
18247 if (!wxPyCheckForApp()) SWIG_fail;
18248 PyThreadState* __tstate = wxPyBeginAllowThreads();
18249 result = (wxPrinterDC *)new wxPrinterDC((wxPrintData const &)*arg1);
18250
18251 wxPyEndAllowThreads(__tstate);
18252 if (PyErr_Occurred()) SWIG_fail;
18253 }
18254 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrinterDC, 1);
18255 return resultobj;
18256 fail:
18257 return NULL;
18258 }
18259
18260
18261 static PyObject * PrinterDC_swigregister(PyObject *, PyObject *args) {
18262 PyObject *obj;
18263 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18264 SWIG_TypeClientData(SWIGTYPE_p_wxPrinterDC, obj);
18265 Py_INCREF(obj);
18266 return Py_BuildValue((char *)"");
18267 }
18268 static PyObject *_wrap_new_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
18269 PyObject *resultobj;
18270 int arg1 ;
18271 int arg2 ;
18272 int arg3 = (int) true ;
18273 int arg4 = (int) 1 ;
18274 wxImageList *result;
18275 PyObject * obj0 = 0 ;
18276 PyObject * obj1 = 0 ;
18277 PyObject * obj2 = 0 ;
18278 PyObject * obj3 = 0 ;
18279 char *kwnames[] = {
18280 (char *) "width",(char *) "height",(char *) "mask",(char *) "initialCount", NULL
18281 };
18282
18283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_ImageList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18284 {
18285 arg1 = (int)(SWIG_As_int(obj0));
18286 if (SWIG_arg_fail(1)) SWIG_fail;
18287 }
18288 {
18289 arg2 = (int)(SWIG_As_int(obj1));
18290 if (SWIG_arg_fail(2)) SWIG_fail;
18291 }
18292 if (obj2) {
18293 {
18294 arg3 = (int)(SWIG_As_int(obj2));
18295 if (SWIG_arg_fail(3)) SWIG_fail;
18296 }
18297 }
18298 if (obj3) {
18299 {
18300 arg4 = (int)(SWIG_As_int(obj3));
18301 if (SWIG_arg_fail(4)) SWIG_fail;
18302 }
18303 }
18304 {
18305 if (!wxPyCheckForApp()) SWIG_fail;
18306 PyThreadState* __tstate = wxPyBeginAllowThreads();
18307 result = (wxImageList *)new wxImageList(arg1,arg2,arg3,arg4);
18308
18309 wxPyEndAllowThreads(__tstate);
18310 if (PyErr_Occurred()) SWIG_fail;
18311 }
18312 {
18313 resultobj = wxPyMake_wxObject(result, 1);
18314 }
18315 return resultobj;
18316 fail:
18317 return NULL;
18318 }
18319
18320
18321 static PyObject *_wrap_delete_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
18322 PyObject *resultobj;
18323 wxImageList *arg1 = (wxImageList *) 0 ;
18324 PyObject * obj0 = 0 ;
18325 char *kwnames[] = {
18326 (char *) "self", NULL
18327 };
18328
18329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ImageList",kwnames,&obj0)) goto fail;
18330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18331 if (SWIG_arg_fail(1)) SWIG_fail;
18332 {
18333 PyThreadState* __tstate = wxPyBeginAllowThreads();
18334 delete arg1;
18335
18336 wxPyEndAllowThreads(__tstate);
18337 if (PyErr_Occurred()) SWIG_fail;
18338 }
18339 Py_INCREF(Py_None); resultobj = Py_None;
18340 return resultobj;
18341 fail:
18342 return NULL;
18343 }
18344
18345
18346 static PyObject *_wrap_ImageList_Add(PyObject *, PyObject *args, PyObject *kwargs) {
18347 PyObject *resultobj;
18348 wxImageList *arg1 = (wxImageList *) 0 ;
18349 wxBitmap *arg2 = 0 ;
18350 wxBitmap const &arg3_defvalue = wxNullBitmap ;
18351 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
18352 int result;
18353 PyObject * obj0 = 0 ;
18354 PyObject * obj1 = 0 ;
18355 PyObject * obj2 = 0 ;
18356 char *kwnames[] = {
18357 (char *) "self",(char *) "bitmap",(char *) "mask", NULL
18358 };
18359
18360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ImageList_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
18361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18362 if (SWIG_arg_fail(1)) SWIG_fail;
18363 {
18364 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18365 if (SWIG_arg_fail(2)) SWIG_fail;
18366 if (arg2 == NULL) {
18367 SWIG_null_ref("wxBitmap");
18368 }
18369 if (SWIG_arg_fail(2)) SWIG_fail;
18370 }
18371 if (obj2) {
18372 {
18373 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18374 if (SWIG_arg_fail(3)) SWIG_fail;
18375 if (arg3 == NULL) {
18376 SWIG_null_ref("wxBitmap");
18377 }
18378 if (SWIG_arg_fail(3)) SWIG_fail;
18379 }
18380 }
18381 {
18382 PyThreadState* __tstate = wxPyBeginAllowThreads();
18383 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
18384
18385 wxPyEndAllowThreads(__tstate);
18386 if (PyErr_Occurred()) SWIG_fail;
18387 }
18388 {
18389 resultobj = SWIG_From_int((int)(result));
18390 }
18391 return resultobj;
18392 fail:
18393 return NULL;
18394 }
18395
18396
18397 static PyObject *_wrap_ImageList_AddWithColourMask(PyObject *, PyObject *args, PyObject *kwargs) {
18398 PyObject *resultobj;
18399 wxImageList *arg1 = (wxImageList *) 0 ;
18400 wxBitmap *arg2 = 0 ;
18401 wxColour *arg3 = 0 ;
18402 int result;
18403 wxColour temp3 ;
18404 PyObject * obj0 = 0 ;
18405 PyObject * obj1 = 0 ;
18406 PyObject * obj2 = 0 ;
18407 char *kwnames[] = {
18408 (char *) "self",(char *) "bitmap",(char *) "maskColour", NULL
18409 };
18410
18411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_AddWithColourMask",kwnames,&obj0,&obj1,&obj2)) goto fail;
18412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18413 if (SWIG_arg_fail(1)) SWIG_fail;
18414 {
18415 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18416 if (SWIG_arg_fail(2)) SWIG_fail;
18417 if (arg2 == NULL) {
18418 SWIG_null_ref("wxBitmap");
18419 }
18420 if (SWIG_arg_fail(2)) SWIG_fail;
18421 }
18422 {
18423 arg3 = &temp3;
18424 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
18425 }
18426 {
18427 PyThreadState* __tstate = wxPyBeginAllowThreads();
18428 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxColour const &)*arg3);
18429
18430 wxPyEndAllowThreads(__tstate);
18431 if (PyErr_Occurred()) SWIG_fail;
18432 }
18433 {
18434 resultobj = SWIG_From_int((int)(result));
18435 }
18436 return resultobj;
18437 fail:
18438 return NULL;
18439 }
18440
18441
18442 static PyObject *_wrap_ImageList_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
18443 PyObject *resultobj;
18444 wxImageList *arg1 = (wxImageList *) 0 ;
18445 wxIcon *arg2 = 0 ;
18446 int result;
18447 PyObject * obj0 = 0 ;
18448 PyObject * obj1 = 0 ;
18449 char *kwnames[] = {
18450 (char *) "self",(char *) "icon", NULL
18451 };
18452
18453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_AddIcon",kwnames,&obj0,&obj1)) goto fail;
18454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18455 if (SWIG_arg_fail(1)) SWIG_fail;
18456 {
18457 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
18458 if (SWIG_arg_fail(2)) SWIG_fail;
18459 if (arg2 == NULL) {
18460 SWIG_null_ref("wxIcon");
18461 }
18462 if (SWIG_arg_fail(2)) SWIG_fail;
18463 }
18464 {
18465 PyThreadState* __tstate = wxPyBeginAllowThreads();
18466 result = (int)(arg1)->Add((wxIcon const &)*arg2);
18467
18468 wxPyEndAllowThreads(__tstate);
18469 if (PyErr_Occurred()) SWIG_fail;
18470 }
18471 {
18472 resultobj = SWIG_From_int((int)(result));
18473 }
18474 return resultobj;
18475 fail:
18476 return NULL;
18477 }
18478
18479
18480 static PyObject *_wrap_ImageList_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
18481 PyObject *resultobj;
18482 wxImageList *arg1 = (wxImageList *) 0 ;
18483 int arg2 ;
18484 wxBitmap *arg3 = 0 ;
18485 bool result;
18486 PyObject * obj0 = 0 ;
18487 PyObject * obj1 = 0 ;
18488 PyObject * obj2 = 0 ;
18489 char *kwnames[] = {
18490 (char *) "self",(char *) "index",(char *) "bitmap", NULL
18491 };
18492
18493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_Replace",kwnames,&obj0,&obj1,&obj2)) goto fail;
18494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18495 if (SWIG_arg_fail(1)) SWIG_fail;
18496 {
18497 arg2 = (int)(SWIG_As_int(obj1));
18498 if (SWIG_arg_fail(2)) SWIG_fail;
18499 }
18500 {
18501 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18502 if (SWIG_arg_fail(3)) SWIG_fail;
18503 if (arg3 == NULL) {
18504 SWIG_null_ref("wxBitmap");
18505 }
18506 if (SWIG_arg_fail(3)) SWIG_fail;
18507 }
18508 {
18509 PyThreadState* __tstate = wxPyBeginAllowThreads();
18510 result = (bool)(arg1)->Replace(arg2,(wxBitmap const &)*arg3);
18511
18512 wxPyEndAllowThreads(__tstate);
18513 if (PyErr_Occurred()) SWIG_fail;
18514 }
18515 {
18516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18517 }
18518 return resultobj;
18519 fail:
18520 return NULL;
18521 }
18522
18523
18524 static PyObject *_wrap_ImageList_Draw(PyObject *, PyObject *args, PyObject *kwargs) {
18525 PyObject *resultobj;
18526 wxImageList *arg1 = (wxImageList *) 0 ;
18527 int arg2 ;
18528 wxDC *arg3 = 0 ;
18529 int arg4 ;
18530 int arg5 ;
18531 int arg6 = (int) wxIMAGELIST_DRAW_NORMAL ;
18532 bool arg7 = (bool) (bool)false ;
18533 bool result;
18534 PyObject * obj0 = 0 ;
18535 PyObject * obj1 = 0 ;
18536 PyObject * obj2 = 0 ;
18537 PyObject * obj3 = 0 ;
18538 PyObject * obj4 = 0 ;
18539 PyObject * obj5 = 0 ;
18540 PyObject * obj6 = 0 ;
18541 char *kwnames[] = {
18542 (char *) "self",(char *) "index",(char *) "dc",(char *) "x",(char *) "x",(char *) "flags",(char *) "solidBackground", NULL
18543 };
18544
18545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OO:ImageList_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
18546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18547 if (SWIG_arg_fail(1)) SWIG_fail;
18548 {
18549 arg2 = (int)(SWIG_As_int(obj1));
18550 if (SWIG_arg_fail(2)) SWIG_fail;
18551 }
18552 {
18553 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18554 if (SWIG_arg_fail(3)) SWIG_fail;
18555 if (arg3 == NULL) {
18556 SWIG_null_ref("wxDC");
18557 }
18558 if (SWIG_arg_fail(3)) SWIG_fail;
18559 }
18560 {
18561 arg4 = (int)(SWIG_As_int(obj3));
18562 if (SWIG_arg_fail(4)) SWIG_fail;
18563 }
18564 {
18565 arg5 = (int)(SWIG_As_int(obj4));
18566 if (SWIG_arg_fail(5)) SWIG_fail;
18567 }
18568 if (obj5) {
18569 {
18570 arg6 = (int)(SWIG_As_int(obj5));
18571 if (SWIG_arg_fail(6)) SWIG_fail;
18572 }
18573 }
18574 if (obj6) {
18575 {
18576 arg7 = (bool const)(SWIG_As_bool(obj6));
18577 if (SWIG_arg_fail(7)) SWIG_fail;
18578 }
18579 }
18580 {
18581 PyThreadState* __tstate = wxPyBeginAllowThreads();
18582 result = (bool)(arg1)->Draw(arg2,*arg3,arg4,arg5,arg6,arg7);
18583
18584 wxPyEndAllowThreads(__tstate);
18585 if (PyErr_Occurred()) SWIG_fail;
18586 }
18587 {
18588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18589 }
18590 return resultobj;
18591 fail:
18592 return NULL;
18593 }
18594
18595
18596 static PyObject *_wrap_ImageList_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
18597 PyObject *resultobj;
18598 wxImageList *arg1 = (wxImageList *) 0 ;
18599 int result;
18600 PyObject * obj0 = 0 ;
18601 char *kwnames[] = {
18602 (char *) "self", NULL
18603 };
18604
18605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_GetImageCount",kwnames,&obj0)) goto fail;
18606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18607 if (SWIG_arg_fail(1)) SWIG_fail;
18608 {
18609 PyThreadState* __tstate = wxPyBeginAllowThreads();
18610 result = (int)(arg1)->GetImageCount();
18611
18612 wxPyEndAllowThreads(__tstate);
18613 if (PyErr_Occurred()) SWIG_fail;
18614 }
18615 {
18616 resultobj = SWIG_From_int((int)(result));
18617 }
18618 return resultobj;
18619 fail:
18620 return NULL;
18621 }
18622
18623
18624 static PyObject *_wrap_ImageList_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
18625 PyObject *resultobj;
18626 wxImageList *arg1 = (wxImageList *) 0 ;
18627 int arg2 ;
18628 bool result;
18629 PyObject * obj0 = 0 ;
18630 PyObject * obj1 = 0 ;
18631 char *kwnames[] = {
18632 (char *) "self",(char *) "index", NULL
18633 };
18634
18635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_Remove",kwnames,&obj0,&obj1)) goto fail;
18636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18637 if (SWIG_arg_fail(1)) SWIG_fail;
18638 {
18639 arg2 = (int)(SWIG_As_int(obj1));
18640 if (SWIG_arg_fail(2)) SWIG_fail;
18641 }
18642 {
18643 PyThreadState* __tstate = wxPyBeginAllowThreads();
18644 result = (bool)(arg1)->Remove(arg2);
18645
18646 wxPyEndAllowThreads(__tstate);
18647 if (PyErr_Occurred()) SWIG_fail;
18648 }
18649 {
18650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18651 }
18652 return resultobj;
18653 fail:
18654 return NULL;
18655 }
18656
18657
18658 static PyObject *_wrap_ImageList_RemoveAll(PyObject *, PyObject *args, PyObject *kwargs) {
18659 PyObject *resultobj;
18660 wxImageList *arg1 = (wxImageList *) 0 ;
18661 bool result;
18662 PyObject * obj0 = 0 ;
18663 char *kwnames[] = {
18664 (char *) "self", NULL
18665 };
18666
18667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_RemoveAll",kwnames,&obj0)) goto fail;
18668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18669 if (SWIG_arg_fail(1)) SWIG_fail;
18670 {
18671 PyThreadState* __tstate = wxPyBeginAllowThreads();
18672 result = (bool)(arg1)->RemoveAll();
18673
18674 wxPyEndAllowThreads(__tstate);
18675 if (PyErr_Occurred()) SWIG_fail;
18676 }
18677 {
18678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18679 }
18680 return resultobj;
18681 fail:
18682 return NULL;
18683 }
18684
18685
18686 static PyObject *_wrap_ImageList_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18687 PyObject *resultobj;
18688 wxImageList *arg1 = (wxImageList *) 0 ;
18689 int arg2 ;
18690 int *arg3 = 0 ;
18691 int *arg4 = 0 ;
18692 int temp3 ;
18693 int res3 = 0 ;
18694 int temp4 ;
18695 int res4 = 0 ;
18696 PyObject * obj0 = 0 ;
18697 PyObject * obj1 = 0 ;
18698 char *kwnames[] = {
18699 (char *) "self",(char *) "index", NULL
18700 };
18701
18702 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18703 arg4 = &temp4; res4 = SWIG_NEWOBJ;
18704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetSize",kwnames,&obj0,&obj1)) goto fail;
18705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18706 if (SWIG_arg_fail(1)) SWIG_fail;
18707 {
18708 arg2 = (int)(SWIG_As_int(obj1));
18709 if (SWIG_arg_fail(2)) SWIG_fail;
18710 }
18711 {
18712 PyThreadState* __tstate = wxPyBeginAllowThreads();
18713 (arg1)->GetSize(arg2,*arg3,*arg4);
18714
18715 wxPyEndAllowThreads(__tstate);
18716 if (PyErr_Occurred()) SWIG_fail;
18717 }
18718 Py_INCREF(Py_None); resultobj = Py_None;
18719 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18720 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18721 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
18722 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
18723 return resultobj;
18724 fail:
18725 return NULL;
18726 }
18727
18728
18729 static PyObject * ImageList_swigregister(PyObject *, PyObject *args) {
18730 PyObject *obj;
18731 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18732 SWIG_TypeClientData(SWIGTYPE_p_wxImageList, obj);
18733 Py_INCREF(obj);
18734 return Py_BuildValue((char *)"");
18735 }
18736 static int _wrap_NORMAL_FONT_set(PyObject *) {
18737 PyErr_SetString(PyExc_TypeError,"Variable NORMAL_FONT is read-only.");
18738 return 1;
18739 }
18740
18741
18742 static PyObject *_wrap_NORMAL_FONT_get(void) {
18743 PyObject *pyobj;
18744
18745 pyobj = SWIG_NewPointerObj((void *)(wxNORMAL_FONT), SWIGTYPE_p_wxFont, 0);
18746 return pyobj;
18747 }
18748
18749
18750 static int _wrap_SMALL_FONT_set(PyObject *) {
18751 PyErr_SetString(PyExc_TypeError,"Variable SMALL_FONT is read-only.");
18752 return 1;
18753 }
18754
18755
18756 static PyObject *_wrap_SMALL_FONT_get(void) {
18757 PyObject *pyobj;
18758
18759 pyobj = SWIG_NewPointerObj((void *)(wxSMALL_FONT), SWIGTYPE_p_wxFont, 0);
18760 return pyobj;
18761 }
18762
18763
18764 static int _wrap_ITALIC_FONT_set(PyObject *) {
18765 PyErr_SetString(PyExc_TypeError,"Variable ITALIC_FONT is read-only.");
18766 return 1;
18767 }
18768
18769
18770 static PyObject *_wrap_ITALIC_FONT_get(void) {
18771 PyObject *pyobj;
18772
18773 pyobj = SWIG_NewPointerObj((void *)(wxITALIC_FONT), SWIGTYPE_p_wxFont, 0);
18774 return pyobj;
18775 }
18776
18777
18778 static int _wrap_SWISS_FONT_set(PyObject *) {
18779 PyErr_SetString(PyExc_TypeError,"Variable SWISS_FONT is read-only.");
18780 return 1;
18781 }
18782
18783
18784 static PyObject *_wrap_SWISS_FONT_get(void) {
18785 PyObject *pyobj;
18786
18787 pyobj = SWIG_NewPointerObj((void *)(wxSWISS_FONT), SWIGTYPE_p_wxFont, 0);
18788 return pyobj;
18789 }
18790
18791
18792 static int _wrap_RED_PEN_set(PyObject *) {
18793 PyErr_SetString(PyExc_TypeError,"Variable RED_PEN is read-only.");
18794 return 1;
18795 }
18796
18797
18798 static PyObject *_wrap_RED_PEN_get(void) {
18799 PyObject *pyobj;
18800
18801 pyobj = SWIG_NewPointerObj((void *)(wxRED_PEN), SWIGTYPE_p_wxPen, 0);
18802 return pyobj;
18803 }
18804
18805
18806 static int _wrap_CYAN_PEN_set(PyObject *) {
18807 PyErr_SetString(PyExc_TypeError,"Variable CYAN_PEN is read-only.");
18808 return 1;
18809 }
18810
18811
18812 static PyObject *_wrap_CYAN_PEN_get(void) {
18813 PyObject *pyobj;
18814
18815 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_PEN), SWIGTYPE_p_wxPen, 0);
18816 return pyobj;
18817 }
18818
18819
18820 static int _wrap_GREEN_PEN_set(PyObject *) {
18821 PyErr_SetString(PyExc_TypeError,"Variable GREEN_PEN is read-only.");
18822 return 1;
18823 }
18824
18825
18826 static PyObject *_wrap_GREEN_PEN_get(void) {
18827 PyObject *pyobj;
18828
18829 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_PEN), SWIGTYPE_p_wxPen, 0);
18830 return pyobj;
18831 }
18832
18833
18834 static int _wrap_BLACK_PEN_set(PyObject *) {
18835 PyErr_SetString(PyExc_TypeError,"Variable BLACK_PEN is read-only.");
18836 return 1;
18837 }
18838
18839
18840 static PyObject *_wrap_BLACK_PEN_get(void) {
18841 PyObject *pyobj;
18842
18843 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_PEN), SWIGTYPE_p_wxPen, 0);
18844 return pyobj;
18845 }
18846
18847
18848 static int _wrap_WHITE_PEN_set(PyObject *) {
18849 PyErr_SetString(PyExc_TypeError,"Variable WHITE_PEN is read-only.");
18850 return 1;
18851 }
18852
18853
18854 static PyObject *_wrap_WHITE_PEN_get(void) {
18855 PyObject *pyobj;
18856
18857 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_PEN), SWIGTYPE_p_wxPen, 0);
18858 return pyobj;
18859 }
18860
18861
18862 static int _wrap_TRANSPARENT_PEN_set(PyObject *) {
18863 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_PEN is read-only.");
18864 return 1;
18865 }
18866
18867
18868 static PyObject *_wrap_TRANSPARENT_PEN_get(void) {
18869 PyObject *pyobj;
18870
18871 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_PEN), SWIGTYPE_p_wxPen, 0);
18872 return pyobj;
18873 }
18874
18875
18876 static int _wrap_BLACK_DASHED_PEN_set(PyObject *) {
18877 PyErr_SetString(PyExc_TypeError,"Variable BLACK_DASHED_PEN is read-only.");
18878 return 1;
18879 }
18880
18881
18882 static PyObject *_wrap_BLACK_DASHED_PEN_get(void) {
18883 PyObject *pyobj;
18884
18885 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_DASHED_PEN), SWIGTYPE_p_wxPen, 0);
18886 return pyobj;
18887 }
18888
18889
18890 static int _wrap_GREY_PEN_set(PyObject *) {
18891 PyErr_SetString(PyExc_TypeError,"Variable GREY_PEN is read-only.");
18892 return 1;
18893 }
18894
18895
18896 static PyObject *_wrap_GREY_PEN_get(void) {
18897 PyObject *pyobj;
18898
18899 pyobj = SWIG_NewPointerObj((void *)(wxGREY_PEN), SWIGTYPE_p_wxPen, 0);
18900 return pyobj;
18901 }
18902
18903
18904 static int _wrap_MEDIUM_GREY_PEN_set(PyObject *) {
18905 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_PEN is read-only.");
18906 return 1;
18907 }
18908
18909
18910 static PyObject *_wrap_MEDIUM_GREY_PEN_get(void) {
18911 PyObject *pyobj;
18912
18913 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_PEN), SWIGTYPE_p_wxPen, 0);
18914 return pyobj;
18915 }
18916
18917
18918 static int _wrap_LIGHT_GREY_PEN_set(PyObject *) {
18919 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_PEN is read-only.");
18920 return 1;
18921 }
18922
18923
18924 static PyObject *_wrap_LIGHT_GREY_PEN_get(void) {
18925 PyObject *pyobj;
18926
18927 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_PEN), SWIGTYPE_p_wxPen, 0);
18928 return pyobj;
18929 }
18930
18931
18932 static int _wrap_BLUE_BRUSH_set(PyObject *) {
18933 PyErr_SetString(PyExc_TypeError,"Variable BLUE_BRUSH is read-only.");
18934 return 1;
18935 }
18936
18937
18938 static PyObject *_wrap_BLUE_BRUSH_get(void) {
18939 PyObject *pyobj;
18940
18941 pyobj = SWIG_NewPointerObj((void *)(wxBLUE_BRUSH), SWIGTYPE_p_wxBrush, 0);
18942 return pyobj;
18943 }
18944
18945
18946 static int _wrap_GREEN_BRUSH_set(PyObject *) {
18947 PyErr_SetString(PyExc_TypeError,"Variable GREEN_BRUSH is read-only.");
18948 return 1;
18949 }
18950
18951
18952 static PyObject *_wrap_GREEN_BRUSH_get(void) {
18953 PyObject *pyobj;
18954
18955 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_BRUSH), SWIGTYPE_p_wxBrush, 0);
18956 return pyobj;
18957 }
18958
18959
18960 static int _wrap_WHITE_BRUSH_set(PyObject *) {
18961 PyErr_SetString(PyExc_TypeError,"Variable WHITE_BRUSH is read-only.");
18962 return 1;
18963 }
18964
18965
18966 static PyObject *_wrap_WHITE_BRUSH_get(void) {
18967 PyObject *pyobj;
18968
18969 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_BRUSH), SWIGTYPE_p_wxBrush, 0);
18970 return pyobj;
18971 }
18972
18973
18974 static int _wrap_BLACK_BRUSH_set(PyObject *) {
18975 PyErr_SetString(PyExc_TypeError,"Variable BLACK_BRUSH is read-only.");
18976 return 1;
18977 }
18978
18979
18980 static PyObject *_wrap_BLACK_BRUSH_get(void) {
18981 PyObject *pyobj;
18982
18983 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_BRUSH), SWIGTYPE_p_wxBrush, 0);
18984 return pyobj;
18985 }
18986
18987
18988 static int _wrap_TRANSPARENT_BRUSH_set(PyObject *) {
18989 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_BRUSH is read-only.");
18990 return 1;
18991 }
18992
18993
18994 static PyObject *_wrap_TRANSPARENT_BRUSH_get(void) {
18995 PyObject *pyobj;
18996
18997 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_BRUSH), SWIGTYPE_p_wxBrush, 0);
18998 return pyobj;
18999 }
19000
19001
19002 static int _wrap_CYAN_BRUSH_set(PyObject *) {
19003 PyErr_SetString(PyExc_TypeError,"Variable CYAN_BRUSH is read-only.");
19004 return 1;
19005 }
19006
19007
19008 static PyObject *_wrap_CYAN_BRUSH_get(void) {
19009 PyObject *pyobj;
19010
19011 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_BRUSH), SWIGTYPE_p_wxBrush, 0);
19012 return pyobj;
19013 }
19014
19015
19016 static int _wrap_RED_BRUSH_set(PyObject *) {
19017 PyErr_SetString(PyExc_TypeError,"Variable RED_BRUSH is read-only.");
19018 return 1;
19019 }
19020
19021
19022 static PyObject *_wrap_RED_BRUSH_get(void) {
19023 PyObject *pyobj;
19024
19025 pyobj = SWIG_NewPointerObj((void *)(wxRED_BRUSH), SWIGTYPE_p_wxBrush, 0);
19026 return pyobj;
19027 }
19028
19029
19030 static int _wrap_GREY_BRUSH_set(PyObject *) {
19031 PyErr_SetString(PyExc_TypeError,"Variable GREY_BRUSH is read-only.");
19032 return 1;
19033 }
19034
19035
19036 static PyObject *_wrap_GREY_BRUSH_get(void) {
19037 PyObject *pyobj;
19038
19039 pyobj = SWIG_NewPointerObj((void *)(wxGREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19040 return pyobj;
19041 }
19042
19043
19044 static int _wrap_MEDIUM_GREY_BRUSH_set(PyObject *) {
19045 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_BRUSH is read-only.");
19046 return 1;
19047 }
19048
19049
19050 static PyObject *_wrap_MEDIUM_GREY_BRUSH_get(void) {
19051 PyObject *pyobj;
19052
19053 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19054 return pyobj;
19055 }
19056
19057
19058 static int _wrap_LIGHT_GREY_BRUSH_set(PyObject *) {
19059 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_BRUSH is read-only.");
19060 return 1;
19061 }
19062
19063
19064 static PyObject *_wrap_LIGHT_GREY_BRUSH_get(void) {
19065 PyObject *pyobj;
19066
19067 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19068 return pyobj;
19069 }
19070
19071
19072 static int _wrap_BLACK_set(PyObject *) {
19073 PyErr_SetString(PyExc_TypeError,"Variable BLACK is read-only.");
19074 return 1;
19075 }
19076
19077
19078 static PyObject *_wrap_BLACK_get(void) {
19079 PyObject *pyobj;
19080
19081 pyobj = SWIG_NewPointerObj((void *)(wxBLACK), SWIGTYPE_p_wxColour, 0);
19082 return pyobj;
19083 }
19084
19085
19086 static int _wrap_WHITE_set(PyObject *) {
19087 PyErr_SetString(PyExc_TypeError,"Variable WHITE is read-only.");
19088 return 1;
19089 }
19090
19091
19092 static PyObject *_wrap_WHITE_get(void) {
19093 PyObject *pyobj;
19094
19095 pyobj = SWIG_NewPointerObj((void *)(wxWHITE), SWIGTYPE_p_wxColour, 0);
19096 return pyobj;
19097 }
19098
19099
19100 static int _wrap_RED_set(PyObject *) {
19101 PyErr_SetString(PyExc_TypeError,"Variable RED is read-only.");
19102 return 1;
19103 }
19104
19105
19106 static PyObject *_wrap_RED_get(void) {
19107 PyObject *pyobj;
19108
19109 pyobj = SWIG_NewPointerObj((void *)(wxRED), SWIGTYPE_p_wxColour, 0);
19110 return pyobj;
19111 }
19112
19113
19114 static int _wrap_BLUE_set(PyObject *) {
19115 PyErr_SetString(PyExc_TypeError,"Variable BLUE is read-only.");
19116 return 1;
19117 }
19118
19119
19120 static PyObject *_wrap_BLUE_get(void) {
19121 PyObject *pyobj;
19122
19123 pyobj = SWIG_NewPointerObj((void *)(wxBLUE), SWIGTYPE_p_wxColour, 0);
19124 return pyobj;
19125 }
19126
19127
19128 static int _wrap_GREEN_set(PyObject *) {
19129 PyErr_SetString(PyExc_TypeError,"Variable GREEN is read-only.");
19130 return 1;
19131 }
19132
19133
19134 static PyObject *_wrap_GREEN_get(void) {
19135 PyObject *pyobj;
19136
19137 pyobj = SWIG_NewPointerObj((void *)(wxGREEN), SWIGTYPE_p_wxColour, 0);
19138 return pyobj;
19139 }
19140
19141
19142 static int _wrap_CYAN_set(PyObject *) {
19143 PyErr_SetString(PyExc_TypeError,"Variable CYAN is read-only.");
19144 return 1;
19145 }
19146
19147
19148 static PyObject *_wrap_CYAN_get(void) {
19149 PyObject *pyobj;
19150
19151 pyobj = SWIG_NewPointerObj((void *)(wxCYAN), SWIGTYPE_p_wxColour, 0);
19152 return pyobj;
19153 }
19154
19155
19156 static int _wrap_LIGHT_GREY_set(PyObject *) {
19157 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY is read-only.");
19158 return 1;
19159 }
19160
19161
19162 static PyObject *_wrap_LIGHT_GREY_get(void) {
19163 PyObject *pyobj;
19164
19165 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY), SWIGTYPE_p_wxColour, 0);
19166 return pyobj;
19167 }
19168
19169
19170 static int _wrap_STANDARD_CURSOR_set(PyObject *) {
19171 PyErr_SetString(PyExc_TypeError,"Variable STANDARD_CURSOR is read-only.");
19172 return 1;
19173 }
19174
19175
19176 static PyObject *_wrap_STANDARD_CURSOR_get(void) {
19177 PyObject *pyobj;
19178
19179 pyobj = SWIG_NewPointerObj((void *)(wxSTANDARD_CURSOR), SWIGTYPE_p_wxCursor, 0);
19180 return pyobj;
19181 }
19182
19183
19184 static int _wrap_HOURGLASS_CURSOR_set(PyObject *) {
19185 PyErr_SetString(PyExc_TypeError,"Variable HOURGLASS_CURSOR is read-only.");
19186 return 1;
19187 }
19188
19189
19190 static PyObject *_wrap_HOURGLASS_CURSOR_get(void) {
19191 PyObject *pyobj;
19192
19193 pyobj = SWIG_NewPointerObj((void *)(wxHOURGLASS_CURSOR), SWIGTYPE_p_wxCursor, 0);
19194 return pyobj;
19195 }
19196
19197
19198 static int _wrap_CROSS_CURSOR_set(PyObject *) {
19199 PyErr_SetString(PyExc_TypeError,"Variable CROSS_CURSOR is read-only.");
19200 return 1;
19201 }
19202
19203
19204 static PyObject *_wrap_CROSS_CURSOR_get(void) {
19205 PyObject *pyobj;
19206
19207 pyobj = SWIG_NewPointerObj((void *)(wxCROSS_CURSOR), SWIGTYPE_p_wxCursor, 0);
19208 return pyobj;
19209 }
19210
19211
19212 static int _wrap_NullBitmap_set(PyObject *) {
19213 PyErr_SetString(PyExc_TypeError,"Variable NullBitmap is read-only.");
19214 return 1;
19215 }
19216
19217
19218 static PyObject *_wrap_NullBitmap_get(void) {
19219 PyObject *pyobj;
19220
19221 pyobj = SWIG_NewPointerObj((void *)(&wxNullBitmap), SWIGTYPE_p_wxBitmap, 0);
19222 return pyobj;
19223 }
19224
19225
19226 static int _wrap_NullIcon_set(PyObject *) {
19227 PyErr_SetString(PyExc_TypeError,"Variable NullIcon is read-only.");
19228 return 1;
19229 }
19230
19231
19232 static PyObject *_wrap_NullIcon_get(void) {
19233 PyObject *pyobj;
19234
19235 pyobj = SWIG_NewPointerObj((void *)(&wxNullIcon), SWIGTYPE_p_wxIcon, 0);
19236 return pyobj;
19237 }
19238
19239
19240 static int _wrap_NullCursor_set(PyObject *) {
19241 PyErr_SetString(PyExc_TypeError,"Variable NullCursor is read-only.");
19242 return 1;
19243 }
19244
19245
19246 static PyObject *_wrap_NullCursor_get(void) {
19247 PyObject *pyobj;
19248
19249 pyobj = SWIG_NewPointerObj((void *)(&wxNullCursor), SWIGTYPE_p_wxCursor, 0);
19250 return pyobj;
19251 }
19252
19253
19254 static int _wrap_NullPen_set(PyObject *) {
19255 PyErr_SetString(PyExc_TypeError,"Variable NullPen is read-only.");
19256 return 1;
19257 }
19258
19259
19260 static PyObject *_wrap_NullPen_get(void) {
19261 PyObject *pyobj;
19262
19263 pyobj = SWIG_NewPointerObj((void *)(&wxNullPen), SWIGTYPE_p_wxPen, 0);
19264 return pyobj;
19265 }
19266
19267
19268 static int _wrap_NullBrush_set(PyObject *) {
19269 PyErr_SetString(PyExc_TypeError,"Variable NullBrush is read-only.");
19270 return 1;
19271 }
19272
19273
19274 static PyObject *_wrap_NullBrush_get(void) {
19275 PyObject *pyobj;
19276
19277 pyobj = SWIG_NewPointerObj((void *)(&wxNullBrush), SWIGTYPE_p_wxBrush, 0);
19278 return pyobj;
19279 }
19280
19281
19282 static int _wrap_NullPalette_set(PyObject *) {
19283 PyErr_SetString(PyExc_TypeError,"Variable NullPalette is read-only.");
19284 return 1;
19285 }
19286
19287
19288 static PyObject *_wrap_NullPalette_get(void) {
19289 PyObject *pyobj;
19290
19291 pyobj = SWIG_NewPointerObj((void *)(&wxNullPalette), SWIGTYPE_p_wxPalette, 0);
19292 return pyobj;
19293 }
19294
19295
19296 static int _wrap_NullFont_set(PyObject *) {
19297 PyErr_SetString(PyExc_TypeError,"Variable NullFont is read-only.");
19298 return 1;
19299 }
19300
19301
19302 static PyObject *_wrap_NullFont_get(void) {
19303 PyObject *pyobj;
19304
19305 pyobj = SWIG_NewPointerObj((void *)(&wxNullFont), SWIGTYPE_p_wxFont, 0);
19306 return pyobj;
19307 }
19308
19309
19310 static int _wrap_NullColour_set(PyObject *) {
19311 PyErr_SetString(PyExc_TypeError,"Variable NullColour is read-only.");
19312 return 1;
19313 }
19314
19315
19316 static PyObject *_wrap_NullColour_get(void) {
19317 PyObject *pyobj;
19318
19319 pyobj = SWIG_NewPointerObj((void *)(&wxNullColour), SWIGTYPE_p_wxColour, 0);
19320 return pyobj;
19321 }
19322
19323
19324 static PyObject *_wrap_PenList_AddPen(PyObject *, PyObject *args, PyObject *kwargs) {
19325 PyObject *resultobj;
19326 wxPenList *arg1 = (wxPenList *) 0 ;
19327 wxPen *arg2 = (wxPen *) 0 ;
19328 PyObject * obj0 = 0 ;
19329 PyObject * obj1 = 0 ;
19330 char *kwnames[] = {
19331 (char *) "self",(char *) "pen", NULL
19332 };
19333
19334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_AddPen",kwnames,&obj0,&obj1)) goto fail;
19335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19336 if (SWIG_arg_fail(1)) SWIG_fail;
19337 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
19338 if (SWIG_arg_fail(2)) SWIG_fail;
19339 {
19340 PyThreadState* __tstate = wxPyBeginAllowThreads();
19341 (arg1)->AddPen(arg2);
19342
19343 wxPyEndAllowThreads(__tstate);
19344 if (PyErr_Occurred()) SWIG_fail;
19345 }
19346 Py_INCREF(Py_None); resultobj = Py_None;
19347 return resultobj;
19348 fail:
19349 return NULL;
19350 }
19351
19352
19353 static PyObject *_wrap_PenList_FindOrCreatePen(PyObject *, PyObject *args, PyObject *kwargs) {
19354 PyObject *resultobj;
19355 wxPenList *arg1 = (wxPenList *) 0 ;
19356 wxColour *arg2 = 0 ;
19357 int arg3 ;
19358 int arg4 ;
19359 wxPen *result;
19360 wxColour temp2 ;
19361 PyObject * obj0 = 0 ;
19362 PyObject * obj1 = 0 ;
19363 PyObject * obj2 = 0 ;
19364 PyObject * obj3 = 0 ;
19365 char *kwnames[] = {
19366 (char *) "self",(char *) "colour",(char *) "width",(char *) "style", NULL
19367 };
19368
19369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PenList_FindOrCreatePen",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19371 if (SWIG_arg_fail(1)) SWIG_fail;
19372 {
19373 arg2 = &temp2;
19374 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19375 }
19376 {
19377 arg3 = (int)(SWIG_As_int(obj2));
19378 if (SWIG_arg_fail(3)) SWIG_fail;
19379 }
19380 {
19381 arg4 = (int)(SWIG_As_int(obj3));
19382 if (SWIG_arg_fail(4)) SWIG_fail;
19383 }
19384 {
19385 PyThreadState* __tstate = wxPyBeginAllowThreads();
19386 result = (wxPen *)(arg1)->FindOrCreatePen((wxColour const &)*arg2,arg3,arg4);
19387
19388 wxPyEndAllowThreads(__tstate);
19389 if (PyErr_Occurred()) SWIG_fail;
19390 }
19391 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 0);
19392 return resultobj;
19393 fail:
19394 return NULL;
19395 }
19396
19397
19398 static PyObject *_wrap_PenList_RemovePen(PyObject *, PyObject *args, PyObject *kwargs) {
19399 PyObject *resultobj;
19400 wxPenList *arg1 = (wxPenList *) 0 ;
19401 wxPen *arg2 = (wxPen *) 0 ;
19402 PyObject * obj0 = 0 ;
19403 PyObject * obj1 = 0 ;
19404 char *kwnames[] = {
19405 (char *) "self",(char *) "pen", NULL
19406 };
19407
19408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_RemovePen",kwnames,&obj0,&obj1)) goto fail;
19409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19410 if (SWIG_arg_fail(1)) SWIG_fail;
19411 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
19412 if (SWIG_arg_fail(2)) SWIG_fail;
19413 {
19414 PyThreadState* __tstate = wxPyBeginAllowThreads();
19415 (arg1)->RemovePen(arg2);
19416
19417 wxPyEndAllowThreads(__tstate);
19418 if (PyErr_Occurred()) SWIG_fail;
19419 }
19420 Py_INCREF(Py_None); resultobj = Py_None;
19421 return resultobj;
19422 fail:
19423 return NULL;
19424 }
19425
19426
19427 static PyObject *_wrap_PenList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19428 PyObject *resultobj;
19429 wxPenList *arg1 = (wxPenList *) 0 ;
19430 int result;
19431 PyObject * obj0 = 0 ;
19432 char *kwnames[] = {
19433 (char *) "self", NULL
19434 };
19435
19436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PenList_GetCount",kwnames,&obj0)) goto fail;
19437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19438 if (SWIG_arg_fail(1)) SWIG_fail;
19439 {
19440 PyThreadState* __tstate = wxPyBeginAllowThreads();
19441 result = (int)(arg1)->GetCount();
19442
19443 wxPyEndAllowThreads(__tstate);
19444 if (PyErr_Occurred()) SWIG_fail;
19445 }
19446 {
19447 resultobj = SWIG_From_int((int)(result));
19448 }
19449 return resultobj;
19450 fail:
19451 return NULL;
19452 }
19453
19454
19455 static PyObject * PenList_swigregister(PyObject *, PyObject *args) {
19456 PyObject *obj;
19457 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19458 SWIG_TypeClientData(SWIGTYPE_p_wxPenList, obj);
19459 Py_INCREF(obj);
19460 return Py_BuildValue((char *)"");
19461 }
19462 static PyObject *_wrap_BrushList_AddBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19463 PyObject *resultobj;
19464 wxBrushList *arg1 = (wxBrushList *) 0 ;
19465 wxBrush *arg2 = (wxBrush *) 0 ;
19466 PyObject * obj0 = 0 ;
19467 PyObject * obj1 = 0 ;
19468 char *kwnames[] = {
19469 (char *) "self",(char *) "brush", NULL
19470 };
19471
19472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_AddBrush",kwnames,&obj0,&obj1)) goto fail;
19473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19474 if (SWIG_arg_fail(1)) SWIG_fail;
19475 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
19476 if (SWIG_arg_fail(2)) SWIG_fail;
19477 {
19478 PyThreadState* __tstate = wxPyBeginAllowThreads();
19479 (arg1)->AddBrush(arg2);
19480
19481 wxPyEndAllowThreads(__tstate);
19482 if (PyErr_Occurred()) SWIG_fail;
19483 }
19484 Py_INCREF(Py_None); resultobj = Py_None;
19485 return resultobj;
19486 fail:
19487 return NULL;
19488 }
19489
19490
19491 static PyObject *_wrap_BrushList_FindOrCreateBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19492 PyObject *resultobj;
19493 wxBrushList *arg1 = (wxBrushList *) 0 ;
19494 wxColour *arg2 = 0 ;
19495 int arg3 ;
19496 wxBrush *result;
19497 wxColour temp2 ;
19498 PyObject * obj0 = 0 ;
19499 PyObject * obj1 = 0 ;
19500 PyObject * obj2 = 0 ;
19501 char *kwnames[] = {
19502 (char *) "self",(char *) "colour",(char *) "style", NULL
19503 };
19504
19505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:BrushList_FindOrCreateBrush",kwnames,&obj0,&obj1,&obj2)) goto fail;
19506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19507 if (SWIG_arg_fail(1)) SWIG_fail;
19508 {
19509 arg2 = &temp2;
19510 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19511 }
19512 {
19513 arg3 = (int)(SWIG_As_int(obj2));
19514 if (SWIG_arg_fail(3)) SWIG_fail;
19515 }
19516 {
19517 PyThreadState* __tstate = wxPyBeginAllowThreads();
19518 result = (wxBrush *)(arg1)->FindOrCreateBrush((wxColour const &)*arg2,arg3);
19519
19520 wxPyEndAllowThreads(__tstate);
19521 if (PyErr_Occurred()) SWIG_fail;
19522 }
19523 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 0);
19524 return resultobj;
19525 fail:
19526 return NULL;
19527 }
19528
19529
19530 static PyObject *_wrap_BrushList_RemoveBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19531 PyObject *resultobj;
19532 wxBrushList *arg1 = (wxBrushList *) 0 ;
19533 wxBrush *arg2 = (wxBrush *) 0 ;
19534 PyObject * obj0 = 0 ;
19535 PyObject * obj1 = 0 ;
19536 char *kwnames[] = {
19537 (char *) "self",(char *) "brush", NULL
19538 };
19539
19540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_RemoveBrush",kwnames,&obj0,&obj1)) goto fail;
19541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19542 if (SWIG_arg_fail(1)) SWIG_fail;
19543 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
19544 if (SWIG_arg_fail(2)) SWIG_fail;
19545 {
19546 PyThreadState* __tstate = wxPyBeginAllowThreads();
19547 (arg1)->RemoveBrush(arg2);
19548
19549 wxPyEndAllowThreads(__tstate);
19550 if (PyErr_Occurred()) SWIG_fail;
19551 }
19552 Py_INCREF(Py_None); resultobj = Py_None;
19553 return resultobj;
19554 fail:
19555 return NULL;
19556 }
19557
19558
19559 static PyObject *_wrap_BrushList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19560 PyObject *resultobj;
19561 wxBrushList *arg1 = (wxBrushList *) 0 ;
19562 int result;
19563 PyObject * obj0 = 0 ;
19564 char *kwnames[] = {
19565 (char *) "self", NULL
19566 };
19567
19568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BrushList_GetCount",kwnames,&obj0)) goto fail;
19569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19570 if (SWIG_arg_fail(1)) SWIG_fail;
19571 {
19572 PyThreadState* __tstate = wxPyBeginAllowThreads();
19573 result = (int)(arg1)->GetCount();
19574
19575 wxPyEndAllowThreads(__tstate);
19576 if (PyErr_Occurred()) SWIG_fail;
19577 }
19578 {
19579 resultobj = SWIG_From_int((int)(result));
19580 }
19581 return resultobj;
19582 fail:
19583 return NULL;
19584 }
19585
19586
19587 static PyObject * BrushList_swigregister(PyObject *, PyObject *args) {
19588 PyObject *obj;
19589 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19590 SWIG_TypeClientData(SWIGTYPE_p_wxBrushList, obj);
19591 Py_INCREF(obj);
19592 return Py_BuildValue((char *)"");
19593 }
19594 static PyObject *_wrap_new_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
19595 PyObject *resultobj;
19596 wxColourDatabase *result;
19597 char *kwnames[] = {
19598 NULL
19599 };
19600
19601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ColourDatabase",kwnames)) goto fail;
19602 {
19603 if (!wxPyCheckForApp()) SWIG_fail;
19604 PyThreadState* __tstate = wxPyBeginAllowThreads();
19605 result = (wxColourDatabase *)new wxColourDatabase();
19606
19607 wxPyEndAllowThreads(__tstate);
19608 if (PyErr_Occurred()) SWIG_fail;
19609 }
19610 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourDatabase, 1);
19611 return resultobj;
19612 fail:
19613 return NULL;
19614 }
19615
19616
19617 static PyObject *_wrap_delete_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
19618 PyObject *resultobj;
19619 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19620 PyObject * obj0 = 0 ;
19621 char *kwnames[] = {
19622 (char *) "self", NULL
19623 };
19624
19625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ColourDatabase",kwnames,&obj0)) goto fail;
19626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19627 if (SWIG_arg_fail(1)) SWIG_fail;
19628 {
19629 PyThreadState* __tstate = wxPyBeginAllowThreads();
19630 delete arg1;
19631
19632 wxPyEndAllowThreads(__tstate);
19633 if (PyErr_Occurred()) SWIG_fail;
19634 }
19635 Py_INCREF(Py_None); resultobj = Py_None;
19636 return resultobj;
19637 fail:
19638 return NULL;
19639 }
19640
19641
19642 static PyObject *_wrap_ColourDatabase_Find(PyObject *, PyObject *args, PyObject *kwargs) {
19643 PyObject *resultobj;
19644 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19645 wxString *arg2 = 0 ;
19646 wxColour result;
19647 bool temp2 = false ;
19648 PyObject * obj0 = 0 ;
19649 PyObject * obj1 = 0 ;
19650 char *kwnames[] = {
19651 (char *) "self",(char *) "name", NULL
19652 };
19653
19654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_Find",kwnames,&obj0,&obj1)) goto fail;
19655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19656 if (SWIG_arg_fail(1)) SWIG_fail;
19657 {
19658 arg2 = wxString_in_helper(obj1);
19659 if (arg2 == NULL) SWIG_fail;
19660 temp2 = true;
19661 }
19662 {
19663 PyThreadState* __tstate = wxPyBeginAllowThreads();
19664 result = ((wxColourDatabase const *)arg1)->Find((wxString const &)*arg2);
19665
19666 wxPyEndAllowThreads(__tstate);
19667 if (PyErr_Occurred()) SWIG_fail;
19668 }
19669 {
19670 wxColour * resultptr;
19671 resultptr = new wxColour((wxColour &)(result));
19672 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
19673 }
19674 {
19675 if (temp2)
19676 delete arg2;
19677 }
19678 return resultobj;
19679 fail:
19680 {
19681 if (temp2)
19682 delete arg2;
19683 }
19684 return NULL;
19685 }
19686
19687
19688 static PyObject *_wrap_ColourDatabase_FindName(PyObject *, PyObject *args, PyObject *kwargs) {
19689 PyObject *resultobj;
19690 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19691 wxColour *arg2 = 0 ;
19692 wxString result;
19693 wxColour temp2 ;
19694 PyObject * obj0 = 0 ;
19695 PyObject * obj1 = 0 ;
19696 char *kwnames[] = {
19697 (char *) "self",(char *) "colour", NULL
19698 };
19699
19700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_FindName",kwnames,&obj0,&obj1)) goto fail;
19701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19702 if (SWIG_arg_fail(1)) SWIG_fail;
19703 {
19704 arg2 = &temp2;
19705 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19706 }
19707 {
19708 PyThreadState* __tstate = wxPyBeginAllowThreads();
19709 result = ((wxColourDatabase const *)arg1)->FindName((wxColour const &)*arg2);
19710
19711 wxPyEndAllowThreads(__tstate);
19712 if (PyErr_Occurred()) SWIG_fail;
19713 }
19714 {
19715 #if wxUSE_UNICODE
19716 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19717 #else
19718 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19719 #endif
19720 }
19721 return resultobj;
19722 fail:
19723 return NULL;
19724 }
19725
19726
19727 static PyObject *_wrap_ColourDatabase_AddColour(PyObject *, PyObject *args, PyObject *kwargs) {
19728 PyObject *resultobj;
19729 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19730 wxString *arg2 = 0 ;
19731 wxColour *arg3 = 0 ;
19732 bool temp2 = false ;
19733 wxColour temp3 ;
19734 PyObject * obj0 = 0 ;
19735 PyObject * obj1 = 0 ;
19736 PyObject * obj2 = 0 ;
19737 char *kwnames[] = {
19738 (char *) "self",(char *) "name",(char *) "colour", NULL
19739 };
19740
19741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ColourDatabase_AddColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
19742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19743 if (SWIG_arg_fail(1)) SWIG_fail;
19744 {
19745 arg2 = wxString_in_helper(obj1);
19746 if (arg2 == NULL) SWIG_fail;
19747 temp2 = true;
19748 }
19749 {
19750 arg3 = &temp3;
19751 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
19752 }
19753 {
19754 PyThreadState* __tstate = wxPyBeginAllowThreads();
19755 (arg1)->AddColour((wxString const &)*arg2,(wxColour const &)*arg3);
19756
19757 wxPyEndAllowThreads(__tstate);
19758 if (PyErr_Occurred()) SWIG_fail;
19759 }
19760 Py_INCREF(Py_None); resultobj = Py_None;
19761 {
19762 if (temp2)
19763 delete arg2;
19764 }
19765 return resultobj;
19766 fail:
19767 {
19768 if (temp2)
19769 delete arg2;
19770 }
19771 return NULL;
19772 }
19773
19774
19775 static PyObject *_wrap_ColourDatabase_Append(PyObject *, PyObject *args, PyObject *kwargs) {
19776 PyObject *resultobj;
19777 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19778 wxString *arg2 = 0 ;
19779 int arg3 ;
19780 int arg4 ;
19781 int arg5 ;
19782 bool temp2 = false ;
19783 PyObject * obj0 = 0 ;
19784 PyObject * obj1 = 0 ;
19785 PyObject * obj2 = 0 ;
19786 PyObject * obj3 = 0 ;
19787 PyObject * obj4 = 0 ;
19788 char *kwnames[] = {
19789 (char *) "self",(char *) "name",(char *) "red",(char *) "green",(char *) "blue", NULL
19790 };
19791
19792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:ColourDatabase_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19794 if (SWIG_arg_fail(1)) SWIG_fail;
19795 {
19796 arg2 = wxString_in_helper(obj1);
19797 if (arg2 == NULL) SWIG_fail;
19798 temp2 = true;
19799 }
19800 {
19801 arg3 = (int)(SWIG_As_int(obj2));
19802 if (SWIG_arg_fail(3)) SWIG_fail;
19803 }
19804 {
19805 arg4 = (int)(SWIG_As_int(obj3));
19806 if (SWIG_arg_fail(4)) SWIG_fail;
19807 }
19808 {
19809 arg5 = (int)(SWIG_As_int(obj4));
19810 if (SWIG_arg_fail(5)) SWIG_fail;
19811 }
19812 {
19813 PyThreadState* __tstate = wxPyBeginAllowThreads();
19814 wxColourDatabase_Append(arg1,(wxString const &)*arg2,arg3,arg4,arg5);
19815
19816 wxPyEndAllowThreads(__tstate);
19817 if (PyErr_Occurred()) SWIG_fail;
19818 }
19819 Py_INCREF(Py_None); resultobj = Py_None;
19820 {
19821 if (temp2)
19822 delete arg2;
19823 }
19824 return resultobj;
19825 fail:
19826 {
19827 if (temp2)
19828 delete arg2;
19829 }
19830 return NULL;
19831 }
19832
19833
19834 static PyObject * ColourDatabase_swigregister(PyObject *, PyObject *args) {
19835 PyObject *obj;
19836 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19837 SWIG_TypeClientData(SWIGTYPE_p_wxColourDatabase, obj);
19838 Py_INCREF(obj);
19839 return Py_BuildValue((char *)"");
19840 }
19841 static PyObject *_wrap_FontList_AddFont(PyObject *, PyObject *args, PyObject *kwargs) {
19842 PyObject *resultobj;
19843 wxFontList *arg1 = (wxFontList *) 0 ;
19844 wxFont *arg2 = (wxFont *) 0 ;
19845 PyObject * obj0 = 0 ;
19846 PyObject * obj1 = 0 ;
19847 char *kwnames[] = {
19848 (char *) "self",(char *) "font", NULL
19849 };
19850
19851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_AddFont",kwnames,&obj0,&obj1)) goto fail;
19852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19853 if (SWIG_arg_fail(1)) SWIG_fail;
19854 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
19855 if (SWIG_arg_fail(2)) SWIG_fail;
19856 {
19857 PyThreadState* __tstate = wxPyBeginAllowThreads();
19858 (arg1)->AddFont(arg2);
19859
19860 wxPyEndAllowThreads(__tstate);
19861 if (PyErr_Occurred()) SWIG_fail;
19862 }
19863 Py_INCREF(Py_None); resultobj = Py_None;
19864 return resultobj;
19865 fail:
19866 return NULL;
19867 }
19868
19869
19870 static PyObject *_wrap_FontList_FindOrCreateFont(PyObject *, PyObject *args, PyObject *kwargs) {
19871 PyObject *resultobj;
19872 wxFontList *arg1 = (wxFontList *) 0 ;
19873 int arg2 ;
19874 int arg3 ;
19875 int arg4 ;
19876 int arg5 ;
19877 bool arg6 = (bool) false ;
19878 wxString const &arg7_defvalue = wxPyEmptyString ;
19879 wxString *arg7 = (wxString *) &arg7_defvalue ;
19880 wxFontEncoding arg8 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
19881 wxFont *result;
19882 bool temp7 = false ;
19883 PyObject * obj0 = 0 ;
19884 PyObject * obj1 = 0 ;
19885 PyObject * obj2 = 0 ;
19886 PyObject * obj3 = 0 ;
19887 PyObject * obj4 = 0 ;
19888 PyObject * obj5 = 0 ;
19889 PyObject * obj6 = 0 ;
19890 PyObject * obj7 = 0 ;
19891 char *kwnames[] = {
19892 (char *) "self",(char *) "point_size",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "facename",(char *) "encoding", NULL
19893 };
19894
19895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:FontList_FindOrCreateFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
19896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19897 if (SWIG_arg_fail(1)) SWIG_fail;
19898 {
19899 arg2 = (int)(SWIG_As_int(obj1));
19900 if (SWIG_arg_fail(2)) SWIG_fail;
19901 }
19902 {
19903 arg3 = (int)(SWIG_As_int(obj2));
19904 if (SWIG_arg_fail(3)) SWIG_fail;
19905 }
19906 {
19907 arg4 = (int)(SWIG_As_int(obj3));
19908 if (SWIG_arg_fail(4)) SWIG_fail;
19909 }
19910 {
19911 arg5 = (int)(SWIG_As_int(obj4));
19912 if (SWIG_arg_fail(5)) SWIG_fail;
19913 }
19914 if (obj5) {
19915 {
19916 arg6 = (bool)(SWIG_As_bool(obj5));
19917 if (SWIG_arg_fail(6)) SWIG_fail;
19918 }
19919 }
19920 if (obj6) {
19921 {
19922 arg7 = wxString_in_helper(obj6);
19923 if (arg7 == NULL) SWIG_fail;
19924 temp7 = true;
19925 }
19926 }
19927 if (obj7) {
19928 {
19929 arg8 = (wxFontEncoding)(SWIG_As_int(obj7));
19930 if (SWIG_arg_fail(8)) SWIG_fail;
19931 }
19932 }
19933 {
19934 PyThreadState* __tstate = wxPyBeginAllowThreads();
19935 result = (wxFont *)(arg1)->FindOrCreateFont(arg2,arg3,arg4,arg5,arg6,(wxString const &)*arg7,(wxFontEncoding )arg8);
19936
19937 wxPyEndAllowThreads(__tstate);
19938 if (PyErr_Occurred()) SWIG_fail;
19939 }
19940 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
19941 {
19942 if (temp7)
19943 delete arg7;
19944 }
19945 return resultobj;
19946 fail:
19947 {
19948 if (temp7)
19949 delete arg7;
19950 }
19951 return NULL;
19952 }
19953
19954
19955 static PyObject *_wrap_FontList_RemoveFont(PyObject *, PyObject *args, PyObject *kwargs) {
19956 PyObject *resultobj;
19957 wxFontList *arg1 = (wxFontList *) 0 ;
19958 wxFont *arg2 = (wxFont *) 0 ;
19959 PyObject * obj0 = 0 ;
19960 PyObject * obj1 = 0 ;
19961 char *kwnames[] = {
19962 (char *) "self",(char *) "font", NULL
19963 };
19964
19965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_RemoveFont",kwnames,&obj0,&obj1)) goto fail;
19966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19967 if (SWIG_arg_fail(1)) SWIG_fail;
19968 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
19969 if (SWIG_arg_fail(2)) SWIG_fail;
19970 {
19971 PyThreadState* __tstate = wxPyBeginAllowThreads();
19972 (arg1)->RemoveFont(arg2);
19973
19974 wxPyEndAllowThreads(__tstate);
19975 if (PyErr_Occurred()) SWIG_fail;
19976 }
19977 Py_INCREF(Py_None); resultobj = Py_None;
19978 return resultobj;
19979 fail:
19980 return NULL;
19981 }
19982
19983
19984 static PyObject *_wrap_FontList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19985 PyObject *resultobj;
19986 wxFontList *arg1 = (wxFontList *) 0 ;
19987 int result;
19988 PyObject * obj0 = 0 ;
19989 char *kwnames[] = {
19990 (char *) "self", NULL
19991 };
19992
19993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontList_GetCount",kwnames,&obj0)) goto fail;
19994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19995 if (SWIG_arg_fail(1)) SWIG_fail;
19996 {
19997 PyThreadState* __tstate = wxPyBeginAllowThreads();
19998 result = (int)(arg1)->GetCount();
19999
20000 wxPyEndAllowThreads(__tstate);
20001 if (PyErr_Occurred()) SWIG_fail;
20002 }
20003 {
20004 resultobj = SWIG_From_int((int)(result));
20005 }
20006 return resultobj;
20007 fail:
20008 return NULL;
20009 }
20010
20011
20012 static PyObject * FontList_swigregister(PyObject *, PyObject *args) {
20013 PyObject *obj;
20014 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20015 SWIG_TypeClientData(SWIGTYPE_p_wxFontList, obj);
20016 Py_INCREF(obj);
20017 return Py_BuildValue((char *)"");
20018 }
20019 static int _wrap_TheFontList_set(PyObject *) {
20020 PyErr_SetString(PyExc_TypeError,"Variable TheFontList is read-only.");
20021 return 1;
20022 }
20023
20024
20025 static PyObject *_wrap_TheFontList_get(void) {
20026 PyObject *pyobj;
20027
20028 pyobj = SWIG_NewPointerObj((void *)(wxTheFontList), SWIGTYPE_p_wxFontList, 0);
20029 return pyobj;
20030 }
20031
20032
20033 static int _wrap_ThePenList_set(PyObject *) {
20034 PyErr_SetString(PyExc_TypeError,"Variable ThePenList is read-only.");
20035 return 1;
20036 }
20037
20038
20039 static PyObject *_wrap_ThePenList_get(void) {
20040 PyObject *pyobj;
20041
20042 pyobj = SWIG_NewPointerObj((void *)(wxThePenList), SWIGTYPE_p_wxPenList, 0);
20043 return pyobj;
20044 }
20045
20046
20047 static int _wrap_TheBrushList_set(PyObject *) {
20048 PyErr_SetString(PyExc_TypeError,"Variable TheBrushList is read-only.");
20049 return 1;
20050 }
20051
20052
20053 static PyObject *_wrap_TheBrushList_get(void) {
20054 PyObject *pyobj;
20055
20056 pyobj = SWIG_NewPointerObj((void *)(wxTheBrushList), SWIGTYPE_p_wxBrushList, 0);
20057 return pyobj;
20058 }
20059
20060
20061 static int _wrap_TheColourDatabase_set(PyObject *) {
20062 PyErr_SetString(PyExc_TypeError,"Variable TheColourDatabase is read-only.");
20063 return 1;
20064 }
20065
20066
20067 static PyObject *_wrap_TheColourDatabase_get(void) {
20068 PyObject *pyobj;
20069
20070 pyobj = SWIG_NewPointerObj((void *)(wxTheColourDatabase), SWIGTYPE_p_wxColourDatabase, 0);
20071 return pyobj;
20072 }
20073
20074
20075 static PyObject *_wrap_new_Effects(PyObject *, PyObject *args, PyObject *kwargs) {
20076 PyObject *resultobj;
20077 wxEffects *result;
20078 char *kwnames[] = {
20079 NULL
20080 };
20081
20082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Effects",kwnames)) goto fail;
20083 {
20084 PyThreadState* __tstate = wxPyBeginAllowThreads();
20085 result = (wxEffects *)new wxEffects();
20086
20087 wxPyEndAllowThreads(__tstate);
20088 if (PyErr_Occurred()) SWIG_fail;
20089 }
20090 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEffects, 1);
20091 return resultobj;
20092 fail:
20093 return NULL;
20094 }
20095
20096
20097 static PyObject *_wrap_Effects_GetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
20098 PyObject *resultobj;
20099 wxEffects *arg1 = (wxEffects *) 0 ;
20100 wxColour result;
20101 PyObject * obj0 = 0 ;
20102 char *kwnames[] = {
20103 (char *) "self", NULL
20104 };
20105
20106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetHighlightColour",kwnames,&obj0)) goto fail;
20107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20108 if (SWIG_arg_fail(1)) SWIG_fail;
20109 {
20110 PyThreadState* __tstate = wxPyBeginAllowThreads();
20111 result = ((wxEffects const *)arg1)->GetHighlightColour();
20112
20113 wxPyEndAllowThreads(__tstate);
20114 if (PyErr_Occurred()) SWIG_fail;
20115 }
20116 {
20117 wxColour * resultptr;
20118 resultptr = new wxColour((wxColour &)(result));
20119 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20120 }
20121 return resultobj;
20122 fail:
20123 return NULL;
20124 }
20125
20126
20127 static PyObject *_wrap_Effects_GetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20128 PyObject *resultobj;
20129 wxEffects *arg1 = (wxEffects *) 0 ;
20130 wxColour result;
20131 PyObject * obj0 = 0 ;
20132 char *kwnames[] = {
20133 (char *) "self", NULL
20134 };
20135
20136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetLightShadow",kwnames,&obj0)) goto fail;
20137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20138 if (SWIG_arg_fail(1)) SWIG_fail;
20139 {
20140 PyThreadState* __tstate = wxPyBeginAllowThreads();
20141 result = ((wxEffects const *)arg1)->GetLightShadow();
20142
20143 wxPyEndAllowThreads(__tstate);
20144 if (PyErr_Occurred()) SWIG_fail;
20145 }
20146 {
20147 wxColour * resultptr;
20148 resultptr = new wxColour((wxColour &)(result));
20149 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20150 }
20151 return resultobj;
20152 fail:
20153 return NULL;
20154 }
20155
20156
20157 static PyObject *_wrap_Effects_GetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
20158 PyObject *resultobj;
20159 wxEffects *arg1 = (wxEffects *) 0 ;
20160 wxColour result;
20161 PyObject * obj0 = 0 ;
20162 char *kwnames[] = {
20163 (char *) "self", NULL
20164 };
20165
20166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetFaceColour",kwnames,&obj0)) goto fail;
20167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20168 if (SWIG_arg_fail(1)) SWIG_fail;
20169 {
20170 PyThreadState* __tstate = wxPyBeginAllowThreads();
20171 result = ((wxEffects const *)arg1)->GetFaceColour();
20172
20173 wxPyEndAllowThreads(__tstate);
20174 if (PyErr_Occurred()) SWIG_fail;
20175 }
20176 {
20177 wxColour * resultptr;
20178 resultptr = new wxColour((wxColour &)(result));
20179 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20180 }
20181 return resultobj;
20182 fail:
20183 return NULL;
20184 }
20185
20186
20187 static PyObject *_wrap_Effects_GetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20188 PyObject *resultobj;
20189 wxEffects *arg1 = (wxEffects *) 0 ;
20190 wxColour result;
20191 PyObject * obj0 = 0 ;
20192 char *kwnames[] = {
20193 (char *) "self", NULL
20194 };
20195
20196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetMediumShadow",kwnames,&obj0)) goto fail;
20197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20198 if (SWIG_arg_fail(1)) SWIG_fail;
20199 {
20200 PyThreadState* __tstate = wxPyBeginAllowThreads();
20201 result = ((wxEffects const *)arg1)->GetMediumShadow();
20202
20203 wxPyEndAllowThreads(__tstate);
20204 if (PyErr_Occurred()) SWIG_fail;
20205 }
20206 {
20207 wxColour * resultptr;
20208 resultptr = new wxColour((wxColour &)(result));
20209 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20210 }
20211 return resultobj;
20212 fail:
20213 return NULL;
20214 }
20215
20216
20217 static PyObject *_wrap_Effects_GetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20218 PyObject *resultobj;
20219 wxEffects *arg1 = (wxEffects *) 0 ;
20220 wxColour result;
20221 PyObject * obj0 = 0 ;
20222 char *kwnames[] = {
20223 (char *) "self", NULL
20224 };
20225
20226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetDarkShadow",kwnames,&obj0)) goto fail;
20227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20228 if (SWIG_arg_fail(1)) SWIG_fail;
20229 {
20230 PyThreadState* __tstate = wxPyBeginAllowThreads();
20231 result = ((wxEffects const *)arg1)->GetDarkShadow();
20232
20233 wxPyEndAllowThreads(__tstate);
20234 if (PyErr_Occurred()) SWIG_fail;
20235 }
20236 {
20237 wxColour * resultptr;
20238 resultptr = new wxColour((wxColour &)(result));
20239 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20240 }
20241 return resultobj;
20242 fail:
20243 return NULL;
20244 }
20245
20246
20247 static PyObject *_wrap_Effects_SetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
20248 PyObject *resultobj;
20249 wxEffects *arg1 = (wxEffects *) 0 ;
20250 wxColour *arg2 = 0 ;
20251 wxColour temp2 ;
20252 PyObject * obj0 = 0 ;
20253 PyObject * obj1 = 0 ;
20254 char *kwnames[] = {
20255 (char *) "self",(char *) "c", NULL
20256 };
20257
20258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetHighlightColour",kwnames,&obj0,&obj1)) goto fail;
20259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20260 if (SWIG_arg_fail(1)) SWIG_fail;
20261 {
20262 arg2 = &temp2;
20263 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20264 }
20265 {
20266 PyThreadState* __tstate = wxPyBeginAllowThreads();
20267 (arg1)->SetHighlightColour((wxColour const &)*arg2);
20268
20269 wxPyEndAllowThreads(__tstate);
20270 if (PyErr_Occurred()) SWIG_fail;
20271 }
20272 Py_INCREF(Py_None); resultobj = Py_None;
20273 return resultobj;
20274 fail:
20275 return NULL;
20276 }
20277
20278
20279 static PyObject *_wrap_Effects_SetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20280 PyObject *resultobj;
20281 wxEffects *arg1 = (wxEffects *) 0 ;
20282 wxColour *arg2 = 0 ;
20283 wxColour temp2 ;
20284 PyObject * obj0 = 0 ;
20285 PyObject * obj1 = 0 ;
20286 char *kwnames[] = {
20287 (char *) "self",(char *) "c", NULL
20288 };
20289
20290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetLightShadow",kwnames,&obj0,&obj1)) goto fail;
20291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20292 if (SWIG_arg_fail(1)) SWIG_fail;
20293 {
20294 arg2 = &temp2;
20295 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20296 }
20297 {
20298 PyThreadState* __tstate = wxPyBeginAllowThreads();
20299 (arg1)->SetLightShadow((wxColour const &)*arg2);
20300
20301 wxPyEndAllowThreads(__tstate);
20302 if (PyErr_Occurred()) SWIG_fail;
20303 }
20304 Py_INCREF(Py_None); resultobj = Py_None;
20305 return resultobj;
20306 fail:
20307 return NULL;
20308 }
20309
20310
20311 static PyObject *_wrap_Effects_SetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
20312 PyObject *resultobj;
20313 wxEffects *arg1 = (wxEffects *) 0 ;
20314 wxColour *arg2 = 0 ;
20315 wxColour temp2 ;
20316 PyObject * obj0 = 0 ;
20317 PyObject * obj1 = 0 ;
20318 char *kwnames[] = {
20319 (char *) "self",(char *) "c", NULL
20320 };
20321
20322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetFaceColour",kwnames,&obj0,&obj1)) goto fail;
20323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20324 if (SWIG_arg_fail(1)) SWIG_fail;
20325 {
20326 arg2 = &temp2;
20327 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20328 }
20329 {
20330 PyThreadState* __tstate = wxPyBeginAllowThreads();
20331 (arg1)->SetFaceColour((wxColour const &)*arg2);
20332
20333 wxPyEndAllowThreads(__tstate);
20334 if (PyErr_Occurred()) SWIG_fail;
20335 }
20336 Py_INCREF(Py_None); resultobj = Py_None;
20337 return resultobj;
20338 fail:
20339 return NULL;
20340 }
20341
20342
20343 static PyObject *_wrap_Effects_SetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20344 PyObject *resultobj;
20345 wxEffects *arg1 = (wxEffects *) 0 ;
20346 wxColour *arg2 = 0 ;
20347 wxColour temp2 ;
20348 PyObject * obj0 = 0 ;
20349 PyObject * obj1 = 0 ;
20350 char *kwnames[] = {
20351 (char *) "self",(char *) "c", NULL
20352 };
20353
20354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetMediumShadow",kwnames,&obj0,&obj1)) goto fail;
20355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20356 if (SWIG_arg_fail(1)) SWIG_fail;
20357 {
20358 arg2 = &temp2;
20359 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20360 }
20361 {
20362 PyThreadState* __tstate = wxPyBeginAllowThreads();
20363 (arg1)->SetMediumShadow((wxColour const &)*arg2);
20364
20365 wxPyEndAllowThreads(__tstate);
20366 if (PyErr_Occurred()) SWIG_fail;
20367 }
20368 Py_INCREF(Py_None); resultobj = Py_None;
20369 return resultobj;
20370 fail:
20371 return NULL;
20372 }
20373
20374
20375 static PyObject *_wrap_Effects_SetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20376 PyObject *resultobj;
20377 wxEffects *arg1 = (wxEffects *) 0 ;
20378 wxColour *arg2 = 0 ;
20379 wxColour temp2 ;
20380 PyObject * obj0 = 0 ;
20381 PyObject * obj1 = 0 ;
20382 char *kwnames[] = {
20383 (char *) "self",(char *) "c", NULL
20384 };
20385
20386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetDarkShadow",kwnames,&obj0,&obj1)) goto fail;
20387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20388 if (SWIG_arg_fail(1)) SWIG_fail;
20389 {
20390 arg2 = &temp2;
20391 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20392 }
20393 {
20394 PyThreadState* __tstate = wxPyBeginAllowThreads();
20395 (arg1)->SetDarkShadow((wxColour const &)*arg2);
20396
20397 wxPyEndAllowThreads(__tstate);
20398 if (PyErr_Occurred()) SWIG_fail;
20399 }
20400 Py_INCREF(Py_None); resultobj = Py_None;
20401 return resultobj;
20402 fail:
20403 return NULL;
20404 }
20405
20406
20407 static PyObject *_wrap_Effects_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20408 PyObject *resultobj;
20409 wxEffects *arg1 = (wxEffects *) 0 ;
20410 wxColour *arg2 = 0 ;
20411 wxColour *arg3 = 0 ;
20412 wxColour *arg4 = 0 ;
20413 wxColour *arg5 = 0 ;
20414 wxColour *arg6 = 0 ;
20415 wxColour temp2 ;
20416 wxColour temp3 ;
20417 wxColour temp4 ;
20418 wxColour temp5 ;
20419 wxColour temp6 ;
20420 PyObject * obj0 = 0 ;
20421 PyObject * obj1 = 0 ;
20422 PyObject * obj2 = 0 ;
20423 PyObject * obj3 = 0 ;
20424 PyObject * obj4 = 0 ;
20425 PyObject * obj5 = 0 ;
20426 char *kwnames[] = {
20427 (char *) "self",(char *) "highlightColour",(char *) "lightShadow",(char *) "faceColour",(char *) "mediumShadow",(char *) "darkShadow", NULL
20428 };
20429
20430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Effects_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
20431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20432 if (SWIG_arg_fail(1)) SWIG_fail;
20433 {
20434 arg2 = &temp2;
20435 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20436 }
20437 {
20438 arg3 = &temp3;
20439 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
20440 }
20441 {
20442 arg4 = &temp4;
20443 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
20444 }
20445 {
20446 arg5 = &temp5;
20447 if ( ! wxColour_helper(obj4, &arg5)) SWIG_fail;
20448 }
20449 {
20450 arg6 = &temp6;
20451 if ( ! wxColour_helper(obj5, &arg6)) SWIG_fail;
20452 }
20453 {
20454 PyThreadState* __tstate = wxPyBeginAllowThreads();
20455 (arg1)->Set((wxColour const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,(wxColour const &)*arg5,(wxColour const &)*arg6);
20456
20457 wxPyEndAllowThreads(__tstate);
20458 if (PyErr_Occurred()) SWIG_fail;
20459 }
20460 Py_INCREF(Py_None); resultobj = Py_None;
20461 return resultobj;
20462 fail:
20463 return NULL;
20464 }
20465
20466
20467 static PyObject *_wrap_Effects_DrawSunkenEdge(PyObject *, PyObject *args, PyObject *kwargs) {
20468 PyObject *resultobj;
20469 wxEffects *arg1 = (wxEffects *) 0 ;
20470 wxDC *arg2 = 0 ;
20471 wxRect *arg3 = 0 ;
20472 int arg4 = (int) 1 ;
20473 wxRect temp3 ;
20474 PyObject * obj0 = 0 ;
20475 PyObject * obj1 = 0 ;
20476 PyObject * obj2 = 0 ;
20477 PyObject * obj3 = 0 ;
20478 char *kwnames[] = {
20479 (char *) "self",(char *) "dc",(char *) "rect",(char *) "borderSize", NULL
20480 };
20481
20482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Effects_DrawSunkenEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20484 if (SWIG_arg_fail(1)) SWIG_fail;
20485 {
20486 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20487 if (SWIG_arg_fail(2)) SWIG_fail;
20488 if (arg2 == NULL) {
20489 SWIG_null_ref("wxDC");
20490 }
20491 if (SWIG_arg_fail(2)) SWIG_fail;
20492 }
20493 {
20494 arg3 = &temp3;
20495 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
20496 }
20497 if (obj3) {
20498 {
20499 arg4 = (int)(SWIG_As_int(obj3));
20500 if (SWIG_arg_fail(4)) SWIG_fail;
20501 }
20502 }
20503 {
20504 PyThreadState* __tstate = wxPyBeginAllowThreads();
20505 (arg1)->DrawSunkenEdge(*arg2,(wxRect const &)*arg3,arg4);
20506
20507 wxPyEndAllowThreads(__tstate);
20508 if (PyErr_Occurred()) SWIG_fail;
20509 }
20510 Py_INCREF(Py_None); resultobj = Py_None;
20511 return resultobj;
20512 fail:
20513 return NULL;
20514 }
20515
20516
20517 static PyObject *_wrap_Effects_TileBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
20518 PyObject *resultobj;
20519 wxEffects *arg1 = (wxEffects *) 0 ;
20520 wxRect *arg2 = 0 ;
20521 wxDC *arg3 = 0 ;
20522 wxBitmap *arg4 = 0 ;
20523 bool result;
20524 wxRect temp2 ;
20525 PyObject * obj0 = 0 ;
20526 PyObject * obj1 = 0 ;
20527 PyObject * obj2 = 0 ;
20528 PyObject * obj3 = 0 ;
20529 char *kwnames[] = {
20530 (char *) "self",(char *) "rect",(char *) "dc",(char *) "bitmap", NULL
20531 };
20532
20533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Effects_TileBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20535 if (SWIG_arg_fail(1)) SWIG_fail;
20536 {
20537 arg2 = &temp2;
20538 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
20539 }
20540 {
20541 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20542 if (SWIG_arg_fail(3)) SWIG_fail;
20543 if (arg3 == NULL) {
20544 SWIG_null_ref("wxDC");
20545 }
20546 if (SWIG_arg_fail(3)) SWIG_fail;
20547 }
20548 {
20549 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
20550 if (SWIG_arg_fail(4)) SWIG_fail;
20551 if (arg4 == NULL) {
20552 SWIG_null_ref("wxBitmap");
20553 }
20554 if (SWIG_arg_fail(4)) SWIG_fail;
20555 }
20556 {
20557 PyThreadState* __tstate = wxPyBeginAllowThreads();
20558 result = (bool)(arg1)->TileBitmap((wxRect const &)*arg2,*arg3,*arg4);
20559
20560 wxPyEndAllowThreads(__tstate);
20561 if (PyErr_Occurred()) SWIG_fail;
20562 }
20563 {
20564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20565 }
20566 return resultobj;
20567 fail:
20568 return NULL;
20569 }
20570
20571
20572 static PyObject * Effects_swigregister(PyObject *, PyObject *args) {
20573 PyObject *obj;
20574 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20575 SWIG_TypeClientData(SWIGTYPE_p_wxEffects, obj);
20576 Py_INCREF(obj);
20577 return Py_BuildValue((char *)"");
20578 }
20579 static PyMethodDef SwigMethods[] = {
20580 { (char *)"new_GDIObject", (PyCFunction) _wrap_new_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
20581 { (char *)"delete_GDIObject", (PyCFunction) _wrap_delete_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
20582 { (char *)"GDIObject_GetVisible", (PyCFunction) _wrap_GDIObject_GetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20583 { (char *)"GDIObject_SetVisible", (PyCFunction) _wrap_GDIObject_SetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20584 { (char *)"GDIObject_IsNull", (PyCFunction) _wrap_GDIObject_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
20585 { (char *)"GDIObject_swigregister", GDIObject_swigregister, METH_VARARGS, NULL},
20586 { (char *)"new_Colour", (PyCFunction) _wrap_new_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
20587 { (char *)"new_NamedColour", (PyCFunction) _wrap_new_NamedColour, METH_VARARGS | METH_KEYWORDS, NULL},
20588 { (char *)"new_ColourRGB", (PyCFunction) _wrap_new_ColourRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20589 { (char *)"delete_Colour", (PyCFunction) _wrap_delete_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
20590 { (char *)"Colour_Red", (PyCFunction) _wrap_Colour_Red, METH_VARARGS | METH_KEYWORDS, NULL},
20591 { (char *)"Colour_Green", (PyCFunction) _wrap_Colour_Green, METH_VARARGS | METH_KEYWORDS, NULL},
20592 { (char *)"Colour_Blue", (PyCFunction) _wrap_Colour_Blue, METH_VARARGS | METH_KEYWORDS, NULL},
20593 { (char *)"Colour_Ok", (PyCFunction) _wrap_Colour_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20594 { (char *)"Colour_Set", (PyCFunction) _wrap_Colour_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20595 { (char *)"Colour_SetRGB", (PyCFunction) _wrap_Colour_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20596 { (char *)"Colour_SetFromName", (PyCFunction) _wrap_Colour_SetFromName, METH_VARARGS | METH_KEYWORDS, NULL},
20597 { (char *)"Colour_GetPixel", (PyCFunction) _wrap_Colour_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
20598 { (char *)"Colour___eq__", (PyCFunction) _wrap_Colour___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20599 { (char *)"Colour___ne__", (PyCFunction) _wrap_Colour___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20600 { (char *)"Colour_Get", (PyCFunction) _wrap_Colour_Get, METH_VARARGS | METH_KEYWORDS, NULL},
20601 { (char *)"Colour_GetRGB", (PyCFunction) _wrap_Colour_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20602 { (char *)"Colour_swigregister", Colour_swigregister, METH_VARARGS, NULL},
20603 { (char *)"new_Palette", (PyCFunction) _wrap_new_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
20604 { (char *)"delete_Palette", (PyCFunction) _wrap_delete_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
20605 { (char *)"Palette_GetPixel", (PyCFunction) _wrap_Palette_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
20606 { (char *)"Palette_GetRGB", (PyCFunction) _wrap_Palette_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20607 { (char *)"Palette_GetColoursCount", (PyCFunction) _wrap_Palette_GetColoursCount, METH_VARARGS | METH_KEYWORDS, NULL},
20608 { (char *)"Palette_Ok", (PyCFunction) _wrap_Palette_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20609 { (char *)"Palette_swigregister", Palette_swigregister, METH_VARARGS, NULL},
20610 { (char *)"new_Pen", (PyCFunction) _wrap_new_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
20611 { (char *)"delete_Pen", (PyCFunction) _wrap_delete_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
20612 { (char *)"Pen_GetCap", (PyCFunction) _wrap_Pen_GetCap, METH_VARARGS | METH_KEYWORDS, NULL},
20613 { (char *)"Pen_GetColour", (PyCFunction) _wrap_Pen_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20614 { (char *)"Pen_GetJoin", (PyCFunction) _wrap_Pen_GetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
20615 { (char *)"Pen_GetStyle", (PyCFunction) _wrap_Pen_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20616 { (char *)"Pen_GetWidth", (PyCFunction) _wrap_Pen_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20617 { (char *)"Pen_Ok", (PyCFunction) _wrap_Pen_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20618 { (char *)"Pen_SetCap", (PyCFunction) _wrap_Pen_SetCap, METH_VARARGS | METH_KEYWORDS, NULL},
20619 { (char *)"Pen_SetColour", (PyCFunction) _wrap_Pen_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20620 { (char *)"Pen_SetJoin", (PyCFunction) _wrap_Pen_SetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
20621 { (char *)"Pen_SetStyle", (PyCFunction) _wrap_Pen_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20622 { (char *)"Pen_SetWidth", (PyCFunction) _wrap_Pen_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20623 { (char *)"Pen_SetDashes", (PyCFunction) _wrap_Pen_SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
20624 { (char *)"Pen_GetDashes", (PyCFunction) _wrap_Pen_GetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
20625 { (char *)"Pen__SetDashes", (PyCFunction) _wrap_Pen__SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
20626 { (char *)"Pen___eq__", (PyCFunction) _wrap_Pen___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20627 { (char *)"Pen___ne__", (PyCFunction) _wrap_Pen___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20628 { (char *)"Pen_swigregister", Pen_swigregister, METH_VARARGS, NULL},
20629 { (char *)"new_Brush", (PyCFunction) _wrap_new_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
20630 { (char *)"delete_Brush", (PyCFunction) _wrap_delete_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
20631 { (char *)"Brush_SetColour", (PyCFunction) _wrap_Brush_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20632 { (char *)"Brush_SetStyle", (PyCFunction) _wrap_Brush_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20633 { (char *)"Brush_SetStipple", (PyCFunction) _wrap_Brush_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
20634 { (char *)"Brush_GetColour", (PyCFunction) _wrap_Brush_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20635 { (char *)"Brush_GetStyle", (PyCFunction) _wrap_Brush_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20636 { (char *)"Brush_GetStipple", (PyCFunction) _wrap_Brush_GetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
20637 { (char *)"Brush_IsHatch", (PyCFunction) _wrap_Brush_IsHatch, METH_VARARGS | METH_KEYWORDS, NULL},
20638 { (char *)"Brush_Ok", (PyCFunction) _wrap_Brush_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20639 { (char *)"Brush_MacGetTheme", (PyCFunction) _wrap_Brush_MacGetTheme, METH_VARARGS | METH_KEYWORDS, NULL},
20640 { (char *)"Brush_MacSetTheme", (PyCFunction) _wrap_Brush_MacSetTheme, METH_VARARGS | METH_KEYWORDS, NULL},
20641 { (char *)"Brush_swigregister", Brush_swigregister, METH_VARARGS, NULL},
20642 { (char *)"new_Bitmap", (PyCFunction) _wrap_new_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20643 { (char *)"delete_Bitmap", (PyCFunction) _wrap_delete_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20644 { (char *)"new_EmptyBitmap", (PyCFunction) _wrap_new_EmptyBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20645 { (char *)"new_BitmapFromIcon", (PyCFunction) _wrap_new_BitmapFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20646 { (char *)"new_BitmapFromImage", (PyCFunction) _wrap_new_BitmapFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
20647 { (char *)"new_BitmapFromXPMData", (PyCFunction) _wrap_new_BitmapFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
20648 { (char *)"new_BitmapFromBits", (PyCFunction) _wrap_new_BitmapFromBits, METH_VARARGS | METH_KEYWORDS, NULL},
20649 { (char *)"Bitmap_Ok", (PyCFunction) _wrap_Bitmap_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20650 { (char *)"Bitmap_GetWidth", (PyCFunction) _wrap_Bitmap_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20651 { (char *)"Bitmap_GetHeight", (PyCFunction) _wrap_Bitmap_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20652 { (char *)"Bitmap_GetDepth", (PyCFunction) _wrap_Bitmap_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20653 { (char *)"Bitmap_GetSize", (PyCFunction) _wrap_Bitmap_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20654 { (char *)"Bitmap_ConvertToImage", (PyCFunction) _wrap_Bitmap_ConvertToImage, METH_VARARGS | METH_KEYWORDS, NULL},
20655 { (char *)"Bitmap_GetMask", (PyCFunction) _wrap_Bitmap_GetMask, METH_VARARGS | METH_KEYWORDS, NULL},
20656 { (char *)"Bitmap_SetMask", (PyCFunction) _wrap_Bitmap_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
20657 { (char *)"Bitmap_SetMaskColour", (PyCFunction) _wrap_Bitmap_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
20658 { (char *)"Bitmap_GetSubBitmap", (PyCFunction) _wrap_Bitmap_GetSubBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20659 { (char *)"Bitmap_SaveFile", (PyCFunction) _wrap_Bitmap_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
20660 { (char *)"Bitmap_LoadFile", (PyCFunction) _wrap_Bitmap_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
20661 { (char *)"Bitmap_GetPalette", (PyCFunction) _wrap_Bitmap_GetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
20662 { (char *)"Bitmap_CopyFromIcon", (PyCFunction) _wrap_Bitmap_CopyFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20663 { (char *)"Bitmap_SetHeight", (PyCFunction) _wrap_Bitmap_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20664 { (char *)"Bitmap_SetWidth", (PyCFunction) _wrap_Bitmap_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20665 { (char *)"Bitmap_SetDepth", (PyCFunction) _wrap_Bitmap_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20666 { (char *)"Bitmap_SetSize", (PyCFunction) _wrap_Bitmap_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20667 { (char *)"Bitmap___eq__", (PyCFunction) _wrap_Bitmap___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20668 { (char *)"Bitmap___ne__", (PyCFunction) _wrap_Bitmap___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20669 { (char *)"Bitmap_swigregister", Bitmap_swigregister, METH_VARARGS, NULL},
20670 { (char *)"new_Mask", (PyCFunction) _wrap_new_Mask, METH_VARARGS | METH_KEYWORDS, NULL},
20671 { (char *)"Mask_swigregister", Mask_swigregister, METH_VARARGS, NULL},
20672 { (char *)"new_Icon", (PyCFunction) _wrap_new_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
20673 { (char *)"delete_Icon", (PyCFunction) _wrap_delete_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
20674 { (char *)"new_EmptyIcon", (PyCFunction) _wrap_new_EmptyIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20675 { (char *)"new_IconFromLocation", (PyCFunction) _wrap_new_IconFromLocation, METH_VARARGS | METH_KEYWORDS, NULL},
20676 { (char *)"new_IconFromBitmap", (PyCFunction) _wrap_new_IconFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20677 { (char *)"new_IconFromXPMData", (PyCFunction) _wrap_new_IconFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
20678 { (char *)"Icon_Ok", (PyCFunction) _wrap_Icon_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20679 { (char *)"Icon_GetWidth", (PyCFunction) _wrap_Icon_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20680 { (char *)"Icon_GetHeight", (PyCFunction) _wrap_Icon_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20681 { (char *)"Icon_GetDepth", (PyCFunction) _wrap_Icon_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20682 { (char *)"Icon_SetWidth", (PyCFunction) _wrap_Icon_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20683 { (char *)"Icon_SetHeight", (PyCFunction) _wrap_Icon_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20684 { (char *)"Icon_SetDepth", (PyCFunction) _wrap_Icon_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20685 { (char *)"Icon_CopyFromBitmap", (PyCFunction) _wrap_Icon_CopyFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20686 { (char *)"Icon_swigregister", Icon_swigregister, METH_VARARGS, NULL},
20687 { (char *)"new_IconLocation", (PyCFunction) _wrap_new_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
20688 { (char *)"delete_IconLocation", (PyCFunction) _wrap_delete_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
20689 { (char *)"IconLocation_IsOk", (PyCFunction) _wrap_IconLocation_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
20690 { (char *)"IconLocation_SetFileName", (PyCFunction) _wrap_IconLocation_SetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
20691 { (char *)"IconLocation_GetFileName", (PyCFunction) _wrap_IconLocation_GetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
20692 { (char *)"IconLocation_SetIndex", (PyCFunction) _wrap_IconLocation_SetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
20693 { (char *)"IconLocation_GetIndex", (PyCFunction) _wrap_IconLocation_GetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
20694 { (char *)"IconLocation_swigregister", IconLocation_swigregister, METH_VARARGS, NULL},
20695 { (char *)"new_IconBundle", (PyCFunction) _wrap_new_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
20696 { (char *)"new_IconBundleFromFile", (PyCFunction) _wrap_new_IconBundleFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
20697 { (char *)"new_IconBundleFromIcon", (PyCFunction) _wrap_new_IconBundleFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20698 { (char *)"delete_IconBundle", (PyCFunction) _wrap_delete_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
20699 { (char *)"IconBundle_AddIcon", (PyCFunction) _wrap_IconBundle_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20700 { (char *)"IconBundle_AddIconFromFile", (PyCFunction) _wrap_IconBundle_AddIconFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
20701 { (char *)"IconBundle_GetIcon", (PyCFunction) _wrap_IconBundle_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20702 { (char *)"IconBundle_swigregister", IconBundle_swigregister, METH_VARARGS, NULL},
20703 { (char *)"new_Cursor", (PyCFunction) _wrap_new_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
20704 { (char *)"delete_Cursor", (PyCFunction) _wrap_delete_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
20705 { (char *)"new_StockCursor", (PyCFunction) _wrap_new_StockCursor, METH_VARARGS | METH_KEYWORDS, NULL},
20706 { (char *)"new_CursorFromImage", (PyCFunction) _wrap_new_CursorFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
20707 { (char *)"Cursor_Ok", (PyCFunction) _wrap_Cursor_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20708 { (char *)"Cursor_swigregister", Cursor_swigregister, METH_VARARGS, NULL},
20709 { (char *)"new_Region", (PyCFunction) _wrap_new_Region, METH_VARARGS | METH_KEYWORDS, NULL},
20710 { (char *)"new_RegionFromBitmap", (PyCFunction) _wrap_new_RegionFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20711 { (char *)"new_RegionFromBitmapColour", (PyCFunction) _wrap_new_RegionFromBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
20712 { (char *)"new_RegionFromPoints", (PyCFunction) _wrap_new_RegionFromPoints, METH_VARARGS | METH_KEYWORDS, NULL},
20713 { (char *)"delete_Region", (PyCFunction) _wrap_delete_Region, METH_VARARGS | METH_KEYWORDS, NULL},
20714 { (char *)"Region_Clear", (PyCFunction) _wrap_Region_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
20715 { (char *)"Region_Offset", (PyCFunction) _wrap_Region_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
20716 { (char *)"Region_Contains", (PyCFunction) _wrap_Region_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
20717 { (char *)"Region_ContainsPoint", (PyCFunction) _wrap_Region_ContainsPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20718 { (char *)"Region_ContainsRect", (PyCFunction) _wrap_Region_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
20719 { (char *)"Region_ContainsRectDim", (PyCFunction) _wrap_Region_ContainsRectDim, METH_VARARGS | METH_KEYWORDS, NULL},
20720 { (char *)"Region_GetBox", (PyCFunction) _wrap_Region_GetBox, METH_VARARGS | METH_KEYWORDS, NULL},
20721 { (char *)"Region_Intersect", (PyCFunction) _wrap_Region_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
20722 { (char *)"Region_IntersectRect", (PyCFunction) _wrap_Region_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
20723 { (char *)"Region_IntersectRegion", (PyCFunction) _wrap_Region_IntersectRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20724 { (char *)"Region_IsEmpty", (PyCFunction) _wrap_Region_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
20725 { (char *)"Region_Union", (PyCFunction) _wrap_Region_Union, METH_VARARGS | METH_KEYWORDS, NULL},
20726 { (char *)"Region_UnionRect", (PyCFunction) _wrap_Region_UnionRect, METH_VARARGS | METH_KEYWORDS, NULL},
20727 { (char *)"Region_UnionRegion", (PyCFunction) _wrap_Region_UnionRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20728 { (char *)"Region_Subtract", (PyCFunction) _wrap_Region_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
20729 { (char *)"Region_SubtractRect", (PyCFunction) _wrap_Region_SubtractRect, METH_VARARGS | METH_KEYWORDS, NULL},
20730 { (char *)"Region_SubtractRegion", (PyCFunction) _wrap_Region_SubtractRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20731 { (char *)"Region_Xor", (PyCFunction) _wrap_Region_Xor, METH_VARARGS | METH_KEYWORDS, NULL},
20732 { (char *)"Region_XorRect", (PyCFunction) _wrap_Region_XorRect, METH_VARARGS | METH_KEYWORDS, NULL},
20733 { (char *)"Region_XorRegion", (PyCFunction) _wrap_Region_XorRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20734 { (char *)"Region_ConvertToBitmap", (PyCFunction) _wrap_Region_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20735 { (char *)"Region_UnionBitmap", (PyCFunction) _wrap_Region_UnionBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20736 { (char *)"Region_UnionBitmapColour", (PyCFunction) _wrap_Region_UnionBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
20737 { (char *)"Region_swigregister", Region_swigregister, METH_VARARGS, NULL},
20738 { (char *)"new_RegionIterator", (PyCFunction) _wrap_new_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
20739 { (char *)"delete_RegionIterator", (PyCFunction) _wrap_delete_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
20740 { (char *)"RegionIterator_GetX", (PyCFunction) _wrap_RegionIterator_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
20741 { (char *)"RegionIterator_GetY", (PyCFunction) _wrap_RegionIterator_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
20742 { (char *)"RegionIterator_GetW", (PyCFunction) _wrap_RegionIterator_GetW, METH_VARARGS | METH_KEYWORDS, NULL},
20743 { (char *)"RegionIterator_GetWidth", (PyCFunction) _wrap_RegionIterator_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20744 { (char *)"RegionIterator_GetH", (PyCFunction) _wrap_RegionIterator_GetH, METH_VARARGS | METH_KEYWORDS, NULL},
20745 { (char *)"RegionIterator_GetHeight", (PyCFunction) _wrap_RegionIterator_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20746 { (char *)"RegionIterator_GetRect", (PyCFunction) _wrap_RegionIterator_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
20747 { (char *)"RegionIterator_HaveRects", (PyCFunction) _wrap_RegionIterator_HaveRects, METH_VARARGS | METH_KEYWORDS, NULL},
20748 { (char *)"RegionIterator_Reset", (PyCFunction) _wrap_RegionIterator_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
20749 { (char *)"RegionIterator_Next", (PyCFunction) _wrap_RegionIterator_Next, METH_VARARGS | METH_KEYWORDS, NULL},
20750 { (char *)"RegionIterator___nonzero__", (PyCFunction) _wrap_RegionIterator___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
20751 { (char *)"RegionIterator_swigregister", RegionIterator_swigregister, METH_VARARGS, NULL},
20752 { (char *)"new_NativeFontInfo", (PyCFunction) _wrap_new_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20753 { (char *)"delete_NativeFontInfo", (PyCFunction) _wrap_delete_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20754 { (char *)"NativeFontInfo_Init", (PyCFunction) _wrap_NativeFontInfo_Init, METH_VARARGS | METH_KEYWORDS, NULL},
20755 { (char *)"NativeFontInfo_InitFromFont", (PyCFunction) _wrap_NativeFontInfo_InitFromFont, METH_VARARGS | METH_KEYWORDS, NULL},
20756 { (char *)"NativeFontInfo_GetPointSize", (PyCFunction) _wrap_NativeFontInfo_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20757 { (char *)"NativeFontInfo_GetStyle", (PyCFunction) _wrap_NativeFontInfo_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20758 { (char *)"NativeFontInfo_GetWeight", (PyCFunction) _wrap_NativeFontInfo_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20759 { (char *)"NativeFontInfo_GetUnderlined", (PyCFunction) _wrap_NativeFontInfo_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20760 { (char *)"NativeFontInfo_GetFaceName", (PyCFunction) _wrap_NativeFontInfo_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20761 { (char *)"NativeFontInfo_GetFamily", (PyCFunction) _wrap_NativeFontInfo_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20762 { (char *)"NativeFontInfo_GetEncoding", (PyCFunction) _wrap_NativeFontInfo_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20763 { (char *)"NativeFontInfo_SetPointSize", (PyCFunction) _wrap_NativeFontInfo_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20764 { (char *)"NativeFontInfo_SetStyle", (PyCFunction) _wrap_NativeFontInfo_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20765 { (char *)"NativeFontInfo_SetWeight", (PyCFunction) _wrap_NativeFontInfo_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20766 { (char *)"NativeFontInfo_SetUnderlined", (PyCFunction) _wrap_NativeFontInfo_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20767 { (char *)"NativeFontInfo_SetFaceName", (PyCFunction) _wrap_NativeFontInfo_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20768 { (char *)"NativeFontInfo_SetFamily", (PyCFunction) _wrap_NativeFontInfo_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20769 { (char *)"NativeFontInfo_SetEncoding", (PyCFunction) _wrap_NativeFontInfo_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20770 { (char *)"NativeFontInfo_FromString", (PyCFunction) _wrap_NativeFontInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
20771 { (char *)"NativeFontInfo_ToString", (PyCFunction) _wrap_NativeFontInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
20772 { (char *)"NativeFontInfo___str__", (PyCFunction) _wrap_NativeFontInfo___str__, METH_VARARGS | METH_KEYWORDS, NULL},
20773 { (char *)"NativeFontInfo_FromUserString", (PyCFunction) _wrap_NativeFontInfo_FromUserString, METH_VARARGS | METH_KEYWORDS, NULL},
20774 { (char *)"NativeFontInfo_ToUserString", (PyCFunction) _wrap_NativeFontInfo_ToUserString, METH_VARARGS | METH_KEYWORDS, NULL},
20775 { (char *)"NativeFontInfo_swigregister", NativeFontInfo_swigregister, METH_VARARGS, NULL},
20776 { (char *)"NativeEncodingInfo_facename_set", (PyCFunction) _wrap_NativeEncodingInfo_facename_set, METH_VARARGS | METH_KEYWORDS, NULL},
20777 { (char *)"NativeEncodingInfo_facename_get", (PyCFunction) _wrap_NativeEncodingInfo_facename_get, METH_VARARGS | METH_KEYWORDS, NULL},
20778 { (char *)"NativeEncodingInfo_encoding_set", (PyCFunction) _wrap_NativeEncodingInfo_encoding_set, METH_VARARGS | METH_KEYWORDS, NULL},
20779 { (char *)"NativeEncodingInfo_encoding_get", (PyCFunction) _wrap_NativeEncodingInfo_encoding_get, METH_VARARGS | METH_KEYWORDS, NULL},
20780 { (char *)"new_NativeEncodingInfo", (PyCFunction) _wrap_new_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20781 { (char *)"delete_NativeEncodingInfo", (PyCFunction) _wrap_delete_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20782 { (char *)"NativeEncodingInfo_FromString", (PyCFunction) _wrap_NativeEncodingInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
20783 { (char *)"NativeEncodingInfo_ToString", (PyCFunction) _wrap_NativeEncodingInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
20784 { (char *)"NativeEncodingInfo_swigregister", NativeEncodingInfo_swigregister, METH_VARARGS, NULL},
20785 { (char *)"GetNativeFontEncoding", (PyCFunction) _wrap_GetNativeFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20786 { (char *)"TestFontEncoding", (PyCFunction) _wrap_TestFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20787 { (char *)"new_FontMapper", (PyCFunction) _wrap_new_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
20788 { (char *)"delete_FontMapper", (PyCFunction) _wrap_delete_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
20789 { (char *)"FontMapper_Get", (PyCFunction) _wrap_FontMapper_Get, METH_VARARGS | METH_KEYWORDS, NULL},
20790 { (char *)"FontMapper_Set", (PyCFunction) _wrap_FontMapper_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20791 { (char *)"FontMapper_CharsetToEncoding", (PyCFunction) _wrap_FontMapper_CharsetToEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20792 { (char *)"FontMapper_GetSupportedEncodingsCount", (PyCFunction) _wrap_FontMapper_GetSupportedEncodingsCount, METH_VARARGS | METH_KEYWORDS, NULL},
20793 { (char *)"FontMapper_GetEncoding", (PyCFunction) _wrap_FontMapper_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20794 { (char *)"FontMapper_GetEncodingName", (PyCFunction) _wrap_FontMapper_GetEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
20795 { (char *)"FontMapper_GetEncodingDescription", (PyCFunction) _wrap_FontMapper_GetEncodingDescription, METH_VARARGS | METH_KEYWORDS, NULL},
20796 { (char *)"FontMapper_GetEncodingFromName", (PyCFunction) _wrap_FontMapper_GetEncodingFromName, METH_VARARGS | METH_KEYWORDS, NULL},
20797 { (char *)"FontMapper_SetConfig", (PyCFunction) _wrap_FontMapper_SetConfig, METH_VARARGS | METH_KEYWORDS, NULL},
20798 { (char *)"FontMapper_SetConfigPath", (PyCFunction) _wrap_FontMapper_SetConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
20799 { (char *)"FontMapper_GetDefaultConfigPath", (PyCFunction) _wrap_FontMapper_GetDefaultConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
20800 { (char *)"FontMapper_GetAltForEncoding", (PyCFunction) _wrap_FontMapper_GetAltForEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20801 { (char *)"FontMapper_IsEncodingAvailable", (PyCFunction) _wrap_FontMapper_IsEncodingAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
20802 { (char *)"FontMapper_SetDialogParent", (PyCFunction) _wrap_FontMapper_SetDialogParent, METH_VARARGS | METH_KEYWORDS, NULL},
20803 { (char *)"FontMapper_SetDialogTitle", (PyCFunction) _wrap_FontMapper_SetDialogTitle, METH_VARARGS | METH_KEYWORDS, NULL},
20804 { (char *)"FontMapper_swigregister", FontMapper_swigregister, METH_VARARGS, NULL},
20805 { (char *)"new_Font", (PyCFunction) _wrap_new_Font, METH_VARARGS | METH_KEYWORDS, NULL},
20806 { (char *)"delete_Font", (PyCFunction) _wrap_delete_Font, METH_VARARGS | METH_KEYWORDS, NULL},
20807 { (char *)"new_FontFromNativeInfo", (PyCFunction) _wrap_new_FontFromNativeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20808 { (char *)"new_FontFromNativeInfoString", (PyCFunction) _wrap_new_FontFromNativeInfoString, METH_VARARGS | METH_KEYWORDS, NULL},
20809 { (char *)"new_Font2", (PyCFunction) _wrap_new_Font2, METH_VARARGS | METH_KEYWORDS, NULL},
20810 { (char *)"new_FontFromPixelSize", (PyCFunction) _wrap_new_FontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20811 { (char *)"Font_Ok", (PyCFunction) _wrap_Font_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20812 { (char *)"Font___eq__", (PyCFunction) _wrap_Font___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20813 { (char *)"Font___ne__", (PyCFunction) _wrap_Font___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20814 { (char *)"Font_GetPointSize", (PyCFunction) _wrap_Font_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20815 { (char *)"Font_GetPixelSize", (PyCFunction) _wrap_Font_GetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20816 { (char *)"Font_IsUsingSizeInPixels", (PyCFunction) _wrap_Font_IsUsingSizeInPixels, METH_VARARGS | METH_KEYWORDS, NULL},
20817 { (char *)"Font_GetFamily", (PyCFunction) _wrap_Font_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20818 { (char *)"Font_GetStyle", (PyCFunction) _wrap_Font_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20819 { (char *)"Font_GetWeight", (PyCFunction) _wrap_Font_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20820 { (char *)"Font_GetUnderlined", (PyCFunction) _wrap_Font_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20821 { (char *)"Font_GetFaceName", (PyCFunction) _wrap_Font_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20822 { (char *)"Font_GetEncoding", (PyCFunction) _wrap_Font_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20823 { (char *)"Font_GetNativeFontInfo", (PyCFunction) _wrap_Font_GetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20824 { (char *)"Font_IsFixedWidth", (PyCFunction) _wrap_Font_IsFixedWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20825 { (char *)"Font_GetNativeFontInfoDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoDesc, METH_VARARGS | METH_KEYWORDS, NULL},
20826 { (char *)"Font_GetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
20827 { (char *)"Font_SetPointSize", (PyCFunction) _wrap_Font_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20828 { (char *)"Font_SetPixelSize", (PyCFunction) _wrap_Font_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20829 { (char *)"Font_SetFamily", (PyCFunction) _wrap_Font_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20830 { (char *)"Font_SetStyle", (PyCFunction) _wrap_Font_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20831 { (char *)"Font_SetWeight", (PyCFunction) _wrap_Font_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20832 { (char *)"Font_SetFaceName", (PyCFunction) _wrap_Font_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20833 { (char *)"Font_SetUnderlined", (PyCFunction) _wrap_Font_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20834 { (char *)"Font_SetEncoding", (PyCFunction) _wrap_Font_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20835 { (char *)"Font_SetNativeFontInfo", (PyCFunction) _wrap_Font_SetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20836 { (char *)"Font_SetNativeFontInfoFromString", (PyCFunction) _wrap_Font_SetNativeFontInfoFromString, METH_VARARGS | METH_KEYWORDS, NULL},
20837 { (char *)"Font_SetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_SetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
20838 { (char *)"Font_GetFamilyString", (PyCFunction) _wrap_Font_GetFamilyString, METH_VARARGS | METH_KEYWORDS, NULL},
20839 { (char *)"Font_GetStyleString", (PyCFunction) _wrap_Font_GetStyleString, METH_VARARGS | METH_KEYWORDS, NULL},
20840 { (char *)"Font_GetWeightString", (PyCFunction) _wrap_Font_GetWeightString, METH_VARARGS | METH_KEYWORDS, NULL},
20841 { (char *)"Font_SetNoAntiAliasing", (PyCFunction) _wrap_Font_SetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
20842 { (char *)"Font_GetNoAntiAliasing", (PyCFunction) _wrap_Font_GetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
20843 { (char *)"Font_GetDefaultEncoding", (PyCFunction) _wrap_Font_GetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20844 { (char *)"Font_SetDefaultEncoding", (PyCFunction) _wrap_Font_SetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20845 { (char *)"Font_swigregister", Font_swigregister, METH_VARARGS, NULL},
20846 { (char *)"new_FontEnumerator", (PyCFunction) _wrap_new_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
20847 { (char *)"delete_FontEnumerator", (PyCFunction) _wrap_delete_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
20848 { (char *)"FontEnumerator__setCallbackInfo", (PyCFunction) _wrap_FontEnumerator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20849 { (char *)"FontEnumerator_EnumerateFacenames", (PyCFunction) _wrap_FontEnumerator_EnumerateFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
20850 { (char *)"FontEnumerator_EnumerateEncodings", (PyCFunction) _wrap_FontEnumerator_EnumerateEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
20851 { (char *)"FontEnumerator_GetEncodings", (PyCFunction) _wrap_FontEnumerator_GetEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
20852 { (char *)"FontEnumerator_GetFacenames", (PyCFunction) _wrap_FontEnumerator_GetFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
20853 { (char *)"FontEnumerator_swigregister", FontEnumerator_swigregister, METH_VARARGS, NULL},
20854 { (char *)"LanguageInfo_Language_set", (PyCFunction) _wrap_LanguageInfo_Language_set, METH_VARARGS | METH_KEYWORDS, NULL},
20855 { (char *)"LanguageInfo_Language_get", (PyCFunction) _wrap_LanguageInfo_Language_get, METH_VARARGS | METH_KEYWORDS, NULL},
20856 { (char *)"LanguageInfo_CanonicalName_set", (PyCFunction) _wrap_LanguageInfo_CanonicalName_set, METH_VARARGS | METH_KEYWORDS, NULL},
20857 { (char *)"LanguageInfo_CanonicalName_get", (PyCFunction) _wrap_LanguageInfo_CanonicalName_get, METH_VARARGS | METH_KEYWORDS, NULL},
20858 { (char *)"LanguageInfo_Description_set", (PyCFunction) _wrap_LanguageInfo_Description_set, METH_VARARGS | METH_KEYWORDS, NULL},
20859 { (char *)"LanguageInfo_Description_get", (PyCFunction) _wrap_LanguageInfo_Description_get, METH_VARARGS | METH_KEYWORDS, NULL},
20860 { (char *)"LanguageInfo_swigregister", LanguageInfo_swigregister, METH_VARARGS, NULL},
20861 { (char *)"new_Locale", (PyCFunction) _wrap_new_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
20862 { (char *)"delete_Locale", (PyCFunction) _wrap_delete_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
20863 { (char *)"Locale_Init1", (PyCFunction) _wrap_Locale_Init1, METH_VARARGS | METH_KEYWORDS, NULL},
20864 { (char *)"Locale_Init2", (PyCFunction) _wrap_Locale_Init2, METH_VARARGS | METH_KEYWORDS, NULL},
20865 { (char *)"Locale_GetSystemLanguage", (PyCFunction) _wrap_Locale_GetSystemLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
20866 { (char *)"Locale_GetSystemEncoding", (PyCFunction) _wrap_Locale_GetSystemEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20867 { (char *)"Locale_GetSystemEncodingName", (PyCFunction) _wrap_Locale_GetSystemEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
20868 { (char *)"Locale_IsOk", (PyCFunction) _wrap_Locale_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
20869 { (char *)"Locale_GetLocale", (PyCFunction) _wrap_Locale_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
20870 { (char *)"Locale_GetLanguage", (PyCFunction) _wrap_Locale_GetLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
20871 { (char *)"Locale_GetSysName", (PyCFunction) _wrap_Locale_GetSysName, METH_VARARGS | METH_KEYWORDS, NULL},
20872 { (char *)"Locale_GetCanonicalName", (PyCFunction) _wrap_Locale_GetCanonicalName, METH_VARARGS | METH_KEYWORDS, NULL},
20873 { (char *)"Locale_AddCatalogLookupPathPrefix", (PyCFunction) _wrap_Locale_AddCatalogLookupPathPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
20874 { (char *)"Locale_AddCatalog", (PyCFunction) _wrap_Locale_AddCatalog, METH_VARARGS | METH_KEYWORDS, NULL},
20875 { (char *)"Locale_IsLoaded", (PyCFunction) _wrap_Locale_IsLoaded, METH_VARARGS | METH_KEYWORDS, NULL},
20876 { (char *)"Locale_GetLanguageInfo", (PyCFunction) _wrap_Locale_GetLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20877 { (char *)"Locale_GetLanguageName", (PyCFunction) _wrap_Locale_GetLanguageName, METH_VARARGS | METH_KEYWORDS, NULL},
20878 { (char *)"Locale_FindLanguageInfo", (PyCFunction) _wrap_Locale_FindLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20879 { (char *)"Locale_AddLanguage", (PyCFunction) _wrap_Locale_AddLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
20880 { (char *)"Locale_GetString", (PyCFunction) _wrap_Locale_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
20881 { (char *)"Locale_GetName", (PyCFunction) _wrap_Locale_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
20882 { (char *)"Locale_swigregister", Locale_swigregister, METH_VARARGS, NULL},
20883 { (char *)"GetLocale", (PyCFunction) _wrap_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
20884 { (char *)"GetTranslation", _wrap_GetTranslation, METH_VARARGS, NULL},
20885 { (char *)"new_EncodingConverter", (PyCFunction) _wrap_new_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
20886 { (char *)"delete_EncodingConverter", (PyCFunction) _wrap_delete_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
20887 { (char *)"EncodingConverter_Init", (PyCFunction) _wrap_EncodingConverter_Init, METH_VARARGS | METH_KEYWORDS, NULL},
20888 { (char *)"EncodingConverter_Convert", (PyCFunction) _wrap_EncodingConverter_Convert, METH_VARARGS | METH_KEYWORDS, NULL},
20889 { (char *)"EncodingConverter_GetPlatformEquivalents", (PyCFunction) _wrap_EncodingConverter_GetPlatformEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
20890 { (char *)"EncodingConverter_GetAllEquivalents", (PyCFunction) _wrap_EncodingConverter_GetAllEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
20891 { (char *)"EncodingConverter_CanConvert", (PyCFunction) _wrap_EncodingConverter_CanConvert, METH_VARARGS | METH_KEYWORDS, NULL},
20892 { (char *)"EncodingConverter_swigregister", EncodingConverter_swigregister, METH_VARARGS, NULL},
20893 { (char *)"delete_DC", (PyCFunction) _wrap_delete_DC, METH_VARARGS | METH_KEYWORDS, NULL},
20894 { (char *)"DC_BeginDrawing", (PyCFunction) _wrap_DC_BeginDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
20895 { (char *)"DC_EndDrawing", (PyCFunction) _wrap_DC_EndDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
20896 { (char *)"DC_FloodFill", (PyCFunction) _wrap_DC_FloodFill, METH_VARARGS | METH_KEYWORDS, NULL},
20897 { (char *)"DC_FloodFillPoint", (PyCFunction) _wrap_DC_FloodFillPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20898 { (char *)"DC_GetPixel", (PyCFunction) _wrap_DC_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
20899 { (char *)"DC_GetPixelPoint", (PyCFunction) _wrap_DC_GetPixelPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20900 { (char *)"DC_DrawLine", (PyCFunction) _wrap_DC_DrawLine, METH_VARARGS | METH_KEYWORDS, NULL},
20901 { (char *)"DC_DrawLinePoint", (PyCFunction) _wrap_DC_DrawLinePoint, METH_VARARGS | METH_KEYWORDS, NULL},
20902 { (char *)"DC_CrossHair", (PyCFunction) _wrap_DC_CrossHair, METH_VARARGS | METH_KEYWORDS, NULL},
20903 { (char *)"DC_CrossHairPoint", (PyCFunction) _wrap_DC_CrossHairPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20904 { (char *)"DC_DrawArc", (PyCFunction) _wrap_DC_DrawArc, METH_VARARGS | METH_KEYWORDS, NULL},
20905 { (char *)"DC_DrawArcPoint", (PyCFunction) _wrap_DC_DrawArcPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20906 { (char *)"DC_DrawCheckMark", (PyCFunction) _wrap_DC_DrawCheckMark, METH_VARARGS | METH_KEYWORDS, NULL},
20907 { (char *)"DC_DrawCheckMarkRect", (PyCFunction) _wrap_DC_DrawCheckMarkRect, METH_VARARGS | METH_KEYWORDS, NULL},
20908 { (char *)"DC_DrawEllipticArc", (PyCFunction) _wrap_DC_DrawEllipticArc, METH_VARARGS | METH_KEYWORDS, NULL},
20909 { (char *)"DC_DrawEllipticArcPointSize", (PyCFunction) _wrap_DC_DrawEllipticArcPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20910 { (char *)"DC_DrawPoint", (PyCFunction) _wrap_DC_DrawPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20911 { (char *)"DC_DrawPointPoint", (PyCFunction) _wrap_DC_DrawPointPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20912 { (char *)"DC_DrawRectangle", (PyCFunction) _wrap_DC_DrawRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
20913 { (char *)"DC_DrawRectangleRect", (PyCFunction) _wrap_DC_DrawRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
20914 { (char *)"DC_DrawRectanglePointSize", (PyCFunction) _wrap_DC_DrawRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20915 { (char *)"DC_DrawRoundedRectangle", (PyCFunction) _wrap_DC_DrawRoundedRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
20916 { (char *)"DC_DrawRoundedRectangleRect", (PyCFunction) _wrap_DC_DrawRoundedRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
20917 { (char *)"DC_DrawRoundedRectanglePointSize", (PyCFunction) _wrap_DC_DrawRoundedRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20918 { (char *)"DC_DrawCircle", (PyCFunction) _wrap_DC_DrawCircle, METH_VARARGS | METH_KEYWORDS, NULL},
20919 { (char *)"DC_DrawCirclePoint", (PyCFunction) _wrap_DC_DrawCirclePoint, METH_VARARGS | METH_KEYWORDS, NULL},
20920 { (char *)"DC_DrawEllipse", (PyCFunction) _wrap_DC_DrawEllipse, METH_VARARGS | METH_KEYWORDS, NULL},
20921 { (char *)"DC_DrawEllipseRect", (PyCFunction) _wrap_DC_DrawEllipseRect, METH_VARARGS | METH_KEYWORDS, NULL},
20922 { (char *)"DC_DrawEllipsePointSize", (PyCFunction) _wrap_DC_DrawEllipsePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20923 { (char *)"DC_DrawIcon", (PyCFunction) _wrap_DC_DrawIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20924 { (char *)"DC_DrawIconPoint", (PyCFunction) _wrap_DC_DrawIconPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20925 { (char *)"DC_DrawBitmap", (PyCFunction) _wrap_DC_DrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20926 { (char *)"DC_DrawBitmapPoint", (PyCFunction) _wrap_DC_DrawBitmapPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20927 { (char *)"DC_DrawText", (PyCFunction) _wrap_DC_DrawText, METH_VARARGS | METH_KEYWORDS, NULL},
20928 { (char *)"DC_DrawTextPoint", (PyCFunction) _wrap_DC_DrawTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20929 { (char *)"DC_DrawRotatedText", (PyCFunction) _wrap_DC_DrawRotatedText, METH_VARARGS | METH_KEYWORDS, NULL},
20930 { (char *)"DC_DrawRotatedTextPoint", (PyCFunction) _wrap_DC_DrawRotatedTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20931 { (char *)"DC_Blit", (PyCFunction) _wrap_DC_Blit, METH_VARARGS | METH_KEYWORDS, NULL},
20932 { (char *)"DC_BlitPointSize", (PyCFunction) _wrap_DC_BlitPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20933 { (char *)"DC_SetClippingRegion", (PyCFunction) _wrap_DC_SetClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20934 { (char *)"DC_SetClippingRegionPointSize", (PyCFunction) _wrap_DC_SetClippingRegionPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20935 { (char *)"DC_SetClippingRegionAsRegion", (PyCFunction) _wrap_DC_SetClippingRegionAsRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20936 { (char *)"DC_SetClippingRect", (PyCFunction) _wrap_DC_SetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
20937 { (char *)"DC_DrawLines", (PyCFunction) _wrap_DC_DrawLines, METH_VARARGS | METH_KEYWORDS, NULL},
20938 { (char *)"DC_DrawPolygon", (PyCFunction) _wrap_DC_DrawPolygon, METH_VARARGS | METH_KEYWORDS, NULL},
20939 { (char *)"DC_DrawLabel", (PyCFunction) _wrap_DC_DrawLabel, METH_VARARGS | METH_KEYWORDS, NULL},
20940 { (char *)"DC_DrawImageLabel", (PyCFunction) _wrap_DC_DrawImageLabel, METH_VARARGS | METH_KEYWORDS, NULL},
20941 { (char *)"DC_DrawSpline", (PyCFunction) _wrap_DC_DrawSpline, METH_VARARGS | METH_KEYWORDS, NULL},
20942 { (char *)"DC_Clear", (PyCFunction) _wrap_DC_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
20943 { (char *)"DC_StartDoc", (PyCFunction) _wrap_DC_StartDoc, METH_VARARGS | METH_KEYWORDS, NULL},
20944 { (char *)"DC_EndDoc", (PyCFunction) _wrap_DC_EndDoc, METH_VARARGS | METH_KEYWORDS, NULL},
20945 { (char *)"DC_StartPage", (PyCFunction) _wrap_DC_StartPage, METH_VARARGS | METH_KEYWORDS, NULL},
20946 { (char *)"DC_EndPage", (PyCFunction) _wrap_DC_EndPage, METH_VARARGS | METH_KEYWORDS, NULL},
20947 { (char *)"DC_SetFont", (PyCFunction) _wrap_DC_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
20948 { (char *)"DC_SetPen", (PyCFunction) _wrap_DC_SetPen, METH_VARARGS | METH_KEYWORDS, NULL},
20949 { (char *)"DC_SetBrush", (PyCFunction) _wrap_DC_SetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
20950 { (char *)"DC_SetBackground", (PyCFunction) _wrap_DC_SetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20951 { (char *)"DC_SetBackgroundMode", (PyCFunction) _wrap_DC_SetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
20952 { (char *)"DC_SetPalette", (PyCFunction) _wrap_DC_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
20953 { (char *)"DC_DestroyClippingRegion", (PyCFunction) _wrap_DC_DestroyClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20954 { (char *)"DC_GetClippingBox", (PyCFunction) _wrap_DC_GetClippingBox, METH_VARARGS | METH_KEYWORDS, NULL},
20955 { (char *)"DC_GetClippingRect", (PyCFunction) _wrap_DC_GetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
20956 { (char *)"DC_GetCharHeight", (PyCFunction) _wrap_DC_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20957 { (char *)"DC_GetCharWidth", (PyCFunction) _wrap_DC_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20958 { (char *)"DC_GetTextExtent", (PyCFunction) _wrap_DC_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
20959 { (char *)"DC_GetFullTextExtent", (PyCFunction) _wrap_DC_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
20960 { (char *)"DC_GetMultiLineTextExtent", (PyCFunction) _wrap_DC_GetMultiLineTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
20961 { (char *)"DC_GetPartialTextExtents", (PyCFunction) _wrap_DC_GetPartialTextExtents, METH_VARARGS | METH_KEYWORDS, NULL},
20962 { (char *)"DC_GetSize", (PyCFunction) _wrap_DC_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20963 { (char *)"DC_GetSizeTuple", (PyCFunction) _wrap_DC_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
20964 { (char *)"DC_GetSizeMM", (PyCFunction) _wrap_DC_GetSizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
20965 { (char *)"DC_GetSizeMMTuple", (PyCFunction) _wrap_DC_GetSizeMMTuple, METH_VARARGS | METH_KEYWORDS, NULL},
20966 { (char *)"DC_DeviceToLogicalX", (PyCFunction) _wrap_DC_DeviceToLogicalX, METH_VARARGS | METH_KEYWORDS, NULL},
20967 { (char *)"DC_DeviceToLogicalY", (PyCFunction) _wrap_DC_DeviceToLogicalY, METH_VARARGS | METH_KEYWORDS, NULL},
20968 { (char *)"DC_DeviceToLogicalXRel", (PyCFunction) _wrap_DC_DeviceToLogicalXRel, METH_VARARGS | METH_KEYWORDS, NULL},
20969 { (char *)"DC_DeviceToLogicalYRel", (PyCFunction) _wrap_DC_DeviceToLogicalYRel, METH_VARARGS | METH_KEYWORDS, NULL},
20970 { (char *)"DC_LogicalToDeviceX", (PyCFunction) _wrap_DC_LogicalToDeviceX, METH_VARARGS | METH_KEYWORDS, NULL},
20971 { (char *)"DC_LogicalToDeviceY", (PyCFunction) _wrap_DC_LogicalToDeviceY, METH_VARARGS | METH_KEYWORDS, NULL},
20972 { (char *)"DC_LogicalToDeviceXRel", (PyCFunction) _wrap_DC_LogicalToDeviceXRel, METH_VARARGS | METH_KEYWORDS, NULL},
20973 { (char *)"DC_LogicalToDeviceYRel", (PyCFunction) _wrap_DC_LogicalToDeviceYRel, METH_VARARGS | METH_KEYWORDS, NULL},
20974 { (char *)"DC_CanDrawBitmap", (PyCFunction) _wrap_DC_CanDrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20975 { (char *)"DC_CanGetTextExtent", (PyCFunction) _wrap_DC_CanGetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
20976 { (char *)"DC_GetDepth", (PyCFunction) _wrap_DC_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20977 { (char *)"DC_GetPPI", (PyCFunction) _wrap_DC_GetPPI, METH_VARARGS | METH_KEYWORDS, NULL},
20978 { (char *)"DC_Ok", (PyCFunction) _wrap_DC_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20979 { (char *)"DC_GetBackgroundMode", (PyCFunction) _wrap_DC_GetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
20980 { (char *)"DC_GetBackground", (PyCFunction) _wrap_DC_GetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20981 { (char *)"DC_GetBrush", (PyCFunction) _wrap_DC_GetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
20982 { (char *)"DC_GetFont", (PyCFunction) _wrap_DC_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
20983 { (char *)"DC_GetPen", (PyCFunction) _wrap_DC_GetPen, METH_VARARGS | METH_KEYWORDS, NULL},
20984 { (char *)"DC_GetTextBackground", (PyCFunction) _wrap_DC_GetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20985 { (char *)"DC_GetTextForeground", (PyCFunction) _wrap_DC_GetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
20986 { (char *)"DC_SetTextForeground", (PyCFunction) _wrap_DC_SetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
20987 { (char *)"DC_SetTextBackground", (PyCFunction) _wrap_DC_SetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20988 { (char *)"DC_GetMapMode", (PyCFunction) _wrap_DC_GetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
20989 { (char *)"DC_SetMapMode", (PyCFunction) _wrap_DC_SetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
20990 { (char *)"DC_GetUserScale", (PyCFunction) _wrap_DC_GetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
20991 { (char *)"DC_SetUserScale", (PyCFunction) _wrap_DC_SetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
20992 { (char *)"DC_GetLogicalScale", (PyCFunction) _wrap_DC_GetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
20993 { (char *)"DC_SetLogicalScale", (PyCFunction) _wrap_DC_SetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
20994 { (char *)"DC_GetLogicalOrigin", (PyCFunction) _wrap_DC_GetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
20995 { (char *)"DC_GetLogicalOriginTuple", (PyCFunction) _wrap_DC_GetLogicalOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
20996 { (char *)"DC_SetLogicalOrigin", (PyCFunction) _wrap_DC_SetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
20997 { (char *)"DC_SetLogicalOriginPoint", (PyCFunction) _wrap_DC_SetLogicalOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20998 { (char *)"DC_GetDeviceOrigin", (PyCFunction) _wrap_DC_GetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
20999 { (char *)"DC_GetDeviceOriginTuple", (PyCFunction) _wrap_DC_GetDeviceOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21000 { (char *)"DC_SetDeviceOrigin", (PyCFunction) _wrap_DC_SetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21001 { (char *)"DC_SetDeviceOriginPoint", (PyCFunction) _wrap_DC_SetDeviceOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21002 { (char *)"DC_SetAxisOrientation", (PyCFunction) _wrap_DC_SetAxisOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
21003 { (char *)"DC_GetLogicalFunction", (PyCFunction) _wrap_DC_GetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
21004 { (char *)"DC_SetLogicalFunction", (PyCFunction) _wrap_DC_SetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
21005 { (char *)"DC_ComputeScaleAndOrigin", (PyCFunction) _wrap_DC_ComputeScaleAndOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21006 { (char *)"DC_CalcBoundingBox", (PyCFunction) _wrap_DC_CalcBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21007 { (char *)"DC_CalcBoundingBoxPoint", (PyCFunction) _wrap_DC_CalcBoundingBoxPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21008 { (char *)"DC_ResetBoundingBox", (PyCFunction) _wrap_DC_ResetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21009 { (char *)"DC_MinX", (PyCFunction) _wrap_DC_MinX, METH_VARARGS | METH_KEYWORDS, NULL},
21010 { (char *)"DC_MaxX", (PyCFunction) _wrap_DC_MaxX, METH_VARARGS | METH_KEYWORDS, NULL},
21011 { (char *)"DC_MinY", (PyCFunction) _wrap_DC_MinY, METH_VARARGS | METH_KEYWORDS, NULL},
21012 { (char *)"DC_MaxY", (PyCFunction) _wrap_DC_MaxY, METH_VARARGS | METH_KEYWORDS, NULL},
21013 { (char *)"DC_GetBoundingBox", (PyCFunction) _wrap_DC_GetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21014 { (char *)"DC__DrawPointList", (PyCFunction) _wrap_DC__DrawPointList, METH_VARARGS | METH_KEYWORDS, NULL},
21015 { (char *)"DC__DrawLineList", (PyCFunction) _wrap_DC__DrawLineList, METH_VARARGS | METH_KEYWORDS, NULL},
21016 { (char *)"DC__DrawRectangleList", (PyCFunction) _wrap_DC__DrawRectangleList, METH_VARARGS | METH_KEYWORDS, NULL},
21017 { (char *)"DC__DrawEllipseList", (PyCFunction) _wrap_DC__DrawEllipseList, METH_VARARGS | METH_KEYWORDS, NULL},
21018 { (char *)"DC__DrawPolygonList", (PyCFunction) _wrap_DC__DrawPolygonList, METH_VARARGS | METH_KEYWORDS, NULL},
21019 { (char *)"DC__DrawTextList", (PyCFunction) _wrap_DC__DrawTextList, METH_VARARGS | METH_KEYWORDS, NULL},
21020 { (char *)"DC_swigregister", DC_swigregister, METH_VARARGS, NULL},
21021 { (char *)"new_MemoryDC", (PyCFunction) _wrap_new_MemoryDC, METH_VARARGS | METH_KEYWORDS, NULL},
21022 { (char *)"new_MemoryDCFromDC", (PyCFunction) _wrap_new_MemoryDCFromDC, METH_VARARGS | METH_KEYWORDS, NULL},
21023 { (char *)"MemoryDC_SelectObject", (PyCFunction) _wrap_MemoryDC_SelectObject, METH_VARARGS | METH_KEYWORDS, NULL},
21024 { (char *)"MemoryDC_swigregister", MemoryDC_swigregister, METH_VARARGS, NULL},
21025 { (char *)"new_BufferedDC", _wrap_new_BufferedDC, METH_VARARGS, NULL},
21026 { (char *)"delete_BufferedDC", (PyCFunction) _wrap_delete_BufferedDC, METH_VARARGS | METH_KEYWORDS, NULL},
21027 { (char *)"BufferedDC_UnMask", (PyCFunction) _wrap_BufferedDC_UnMask, METH_VARARGS | METH_KEYWORDS, NULL},
21028 { (char *)"BufferedDC_swigregister", BufferedDC_swigregister, METH_VARARGS, NULL},
21029 { (char *)"new_BufferedPaintDC", (PyCFunction) _wrap_new_BufferedPaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
21030 { (char *)"BufferedPaintDC_swigregister", BufferedPaintDC_swigregister, METH_VARARGS, NULL},
21031 { (char *)"new_ScreenDC", (PyCFunction) _wrap_new_ScreenDC, METH_VARARGS | METH_KEYWORDS, NULL},
21032 { (char *)"ScreenDC_StartDrawingOnTopWin", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTopWin, METH_VARARGS | METH_KEYWORDS, NULL},
21033 { (char *)"ScreenDC_StartDrawingOnTop", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
21034 { (char *)"ScreenDC_EndDrawingOnTop", (PyCFunction) _wrap_ScreenDC_EndDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
21035 { (char *)"ScreenDC_swigregister", ScreenDC_swigregister, METH_VARARGS, NULL},
21036 { (char *)"new_ClientDC", (PyCFunction) _wrap_new_ClientDC, METH_VARARGS | METH_KEYWORDS, NULL},
21037 { (char *)"ClientDC_swigregister", ClientDC_swigregister, METH_VARARGS, NULL},
21038 { (char *)"new_PaintDC", (PyCFunction) _wrap_new_PaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
21039 { (char *)"PaintDC_swigregister", PaintDC_swigregister, METH_VARARGS, NULL},
21040 { (char *)"new_WindowDC", (PyCFunction) _wrap_new_WindowDC, METH_VARARGS | METH_KEYWORDS, NULL},
21041 { (char *)"WindowDC_swigregister", WindowDC_swigregister, METH_VARARGS, NULL},
21042 { (char *)"new_MirrorDC", (PyCFunction) _wrap_new_MirrorDC, METH_VARARGS | METH_KEYWORDS, NULL},
21043 { (char *)"MirrorDC_swigregister", MirrorDC_swigregister, METH_VARARGS, NULL},
21044 { (char *)"new_PostScriptDC", (PyCFunction) _wrap_new_PostScriptDC, METH_VARARGS | METH_KEYWORDS, NULL},
21045 { (char *)"PostScriptDC_GetPrintData", (PyCFunction) _wrap_PostScriptDC_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
21046 { (char *)"PostScriptDC_SetPrintData", (PyCFunction) _wrap_PostScriptDC_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
21047 { (char *)"PostScriptDC_SetResolution", (PyCFunction) _wrap_PostScriptDC_SetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
21048 { (char *)"PostScriptDC_GetResolution", (PyCFunction) _wrap_PostScriptDC_GetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
21049 { (char *)"PostScriptDC_swigregister", PostScriptDC_swigregister, METH_VARARGS, NULL},
21050 { (char *)"new_MetaFile", (PyCFunction) _wrap_new_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
21051 { (char *)"delete_MetaFile", (PyCFunction) _wrap_delete_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
21052 { (char *)"MetaFile_Ok", (PyCFunction) _wrap_MetaFile_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21053 { (char *)"MetaFile_SetClipboard", (PyCFunction) _wrap_MetaFile_SetClipboard, METH_VARARGS | METH_KEYWORDS, NULL},
21054 { (char *)"MetaFile_GetSize", (PyCFunction) _wrap_MetaFile_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21055 { (char *)"MetaFile_GetWidth", (PyCFunction) _wrap_MetaFile_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21056 { (char *)"MetaFile_GetHeight", (PyCFunction) _wrap_MetaFile_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21057 { (char *)"MetaFile_swigregister", MetaFile_swigregister, METH_VARARGS, NULL},
21058 { (char *)"new_MetaFileDC", (PyCFunction) _wrap_new_MetaFileDC, METH_VARARGS | METH_KEYWORDS, NULL},
21059 { (char *)"MetaFileDC_Close", (PyCFunction) _wrap_MetaFileDC_Close, METH_VARARGS | METH_KEYWORDS, NULL},
21060 { (char *)"MetaFileDC_swigregister", MetaFileDC_swigregister, METH_VARARGS, NULL},
21061 { (char *)"new_PrinterDC", (PyCFunction) _wrap_new_PrinterDC, METH_VARARGS | METH_KEYWORDS, NULL},
21062 { (char *)"PrinterDC_swigregister", PrinterDC_swigregister, METH_VARARGS, NULL},
21063 { (char *)"new_ImageList", (PyCFunction) _wrap_new_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
21064 { (char *)"delete_ImageList", (PyCFunction) _wrap_delete_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
21065 { (char *)"ImageList_Add", (PyCFunction) _wrap_ImageList_Add, METH_VARARGS | METH_KEYWORDS, NULL},
21066 { (char *)"ImageList_AddWithColourMask", (PyCFunction) _wrap_ImageList_AddWithColourMask, METH_VARARGS | METH_KEYWORDS, NULL},
21067 { (char *)"ImageList_AddIcon", (PyCFunction) _wrap_ImageList_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21068 { (char *)"ImageList_Replace", (PyCFunction) _wrap_ImageList_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
21069 { (char *)"ImageList_Draw", (PyCFunction) _wrap_ImageList_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
21070 { (char *)"ImageList_GetImageCount", (PyCFunction) _wrap_ImageList_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
21071 { (char *)"ImageList_Remove", (PyCFunction) _wrap_ImageList_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
21072 { (char *)"ImageList_RemoveAll", (PyCFunction) _wrap_ImageList_RemoveAll, METH_VARARGS | METH_KEYWORDS, NULL},
21073 { (char *)"ImageList_GetSize", (PyCFunction) _wrap_ImageList_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21074 { (char *)"ImageList_swigregister", ImageList_swigregister, METH_VARARGS, NULL},
21075 { (char *)"PenList_AddPen", (PyCFunction) _wrap_PenList_AddPen, METH_VARARGS | METH_KEYWORDS, NULL},
21076 { (char *)"PenList_FindOrCreatePen", (PyCFunction) _wrap_PenList_FindOrCreatePen, METH_VARARGS | METH_KEYWORDS, NULL},
21077 { (char *)"PenList_RemovePen", (PyCFunction) _wrap_PenList_RemovePen, METH_VARARGS | METH_KEYWORDS, NULL},
21078 { (char *)"PenList_GetCount", (PyCFunction) _wrap_PenList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21079 { (char *)"PenList_swigregister", PenList_swigregister, METH_VARARGS, NULL},
21080 { (char *)"BrushList_AddBrush", (PyCFunction) _wrap_BrushList_AddBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21081 { (char *)"BrushList_FindOrCreateBrush", (PyCFunction) _wrap_BrushList_FindOrCreateBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21082 { (char *)"BrushList_RemoveBrush", (PyCFunction) _wrap_BrushList_RemoveBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21083 { (char *)"BrushList_GetCount", (PyCFunction) _wrap_BrushList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21084 { (char *)"BrushList_swigregister", BrushList_swigregister, METH_VARARGS, NULL},
21085 { (char *)"new_ColourDatabase", (PyCFunction) _wrap_new_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
21086 { (char *)"delete_ColourDatabase", (PyCFunction) _wrap_delete_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
21087 { (char *)"ColourDatabase_Find", (PyCFunction) _wrap_ColourDatabase_Find, METH_VARARGS | METH_KEYWORDS, NULL},
21088 { (char *)"ColourDatabase_FindName", (PyCFunction) _wrap_ColourDatabase_FindName, METH_VARARGS | METH_KEYWORDS, NULL},
21089 { (char *)"ColourDatabase_AddColour", (PyCFunction) _wrap_ColourDatabase_AddColour, METH_VARARGS | METH_KEYWORDS, NULL},
21090 { (char *)"ColourDatabase_Append", (PyCFunction) _wrap_ColourDatabase_Append, METH_VARARGS | METH_KEYWORDS, NULL},
21091 { (char *)"ColourDatabase_swigregister", ColourDatabase_swigregister, METH_VARARGS, NULL},
21092 { (char *)"FontList_AddFont", (PyCFunction) _wrap_FontList_AddFont, METH_VARARGS | METH_KEYWORDS, NULL},
21093 { (char *)"FontList_FindOrCreateFont", (PyCFunction) _wrap_FontList_FindOrCreateFont, METH_VARARGS | METH_KEYWORDS, NULL},
21094 { (char *)"FontList_RemoveFont", (PyCFunction) _wrap_FontList_RemoveFont, METH_VARARGS | METH_KEYWORDS, NULL},
21095 { (char *)"FontList_GetCount", (PyCFunction) _wrap_FontList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21096 { (char *)"FontList_swigregister", FontList_swigregister, METH_VARARGS, NULL},
21097 { (char *)"new_Effects", (PyCFunction) _wrap_new_Effects, METH_VARARGS | METH_KEYWORDS, NULL},
21098 { (char *)"Effects_GetHighlightColour", (PyCFunction) _wrap_Effects_GetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
21099 { (char *)"Effects_GetLightShadow", (PyCFunction) _wrap_Effects_GetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21100 { (char *)"Effects_GetFaceColour", (PyCFunction) _wrap_Effects_GetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
21101 { (char *)"Effects_GetMediumShadow", (PyCFunction) _wrap_Effects_GetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21102 { (char *)"Effects_GetDarkShadow", (PyCFunction) _wrap_Effects_GetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21103 { (char *)"Effects_SetHighlightColour", (PyCFunction) _wrap_Effects_SetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
21104 { (char *)"Effects_SetLightShadow", (PyCFunction) _wrap_Effects_SetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21105 { (char *)"Effects_SetFaceColour", (PyCFunction) _wrap_Effects_SetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
21106 { (char *)"Effects_SetMediumShadow", (PyCFunction) _wrap_Effects_SetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21107 { (char *)"Effects_SetDarkShadow", (PyCFunction) _wrap_Effects_SetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21108 { (char *)"Effects_Set", (PyCFunction) _wrap_Effects_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21109 { (char *)"Effects_DrawSunkenEdge", (PyCFunction) _wrap_Effects_DrawSunkenEdge, METH_VARARGS | METH_KEYWORDS, NULL},
21110 { (char *)"Effects_TileBitmap", (PyCFunction) _wrap_Effects_TileBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21111 { (char *)"Effects_swigregister", Effects_swigregister, METH_VARARGS, NULL},
21112 { NULL, NULL, 0, NULL }
21113 };
21114
21115
21116 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
21117
21118 static void *_p_wxBufferedDCTo_p_wxMemoryDC(void *x) {
21119 return (void *)((wxMemoryDC *) ((wxBufferedDC *) x));
21120 }
21121 static void *_p_wxBufferedPaintDCTo_p_wxMemoryDC(void *x) {
21122 return (void *)((wxMemoryDC *) (wxBufferedDC *) ((wxBufferedPaintDC *) x));
21123 }
21124 static void *_p_wxIconTo_p_wxGDIObject(void *x) {
21125 return (void *)((wxGDIObject *) ((wxIcon *) x));
21126 }
21127 static void *_p_wxPaletteTo_p_wxGDIObject(void *x) {
21128 return (void *)((wxGDIObject *) ((wxPalette *) x));
21129 }
21130 static void *_p_wxPenTo_p_wxGDIObject(void *x) {
21131 return (void *)((wxGDIObject *) ((wxPen *) x));
21132 }
21133 static void *_p_wxFontTo_p_wxGDIObject(void *x) {
21134 return (void *)((wxGDIObject *) ((wxFont *) x));
21135 }
21136 static void *_p_wxCursorTo_p_wxGDIObject(void *x) {
21137 return (void *)((wxGDIObject *) ((wxCursor *) x));
21138 }
21139 static void *_p_wxBitmapTo_p_wxGDIObject(void *x) {
21140 return (void *)((wxGDIObject *) ((wxBitmap *) x));
21141 }
21142 static void *_p_wxRegionTo_p_wxGDIObject(void *x) {
21143 return (void *)((wxGDIObject *) ((wxRegion *) x));
21144 }
21145 static void *_p_wxBrushTo_p_wxGDIObject(void *x) {
21146 return (void *)((wxGDIObject *) ((wxBrush *) x));
21147 }
21148 static void *_p_wxBufferedDCTo_p_wxDC(void *x) {
21149 return (void *)((wxDC *) (wxMemoryDC *) ((wxBufferedDC *) x));
21150 }
21151 static void *_p_wxScreenDCTo_p_wxDC(void *x) {
21152 return (void *)((wxDC *) ((wxScreenDC *) x));
21153 }
21154 static void *_p_wxMirrorDCTo_p_wxDC(void *x) {
21155 return (void *)((wxDC *) ((wxMirrorDC *) x));
21156 }
21157 static void *_p_wxMemoryDCTo_p_wxDC(void *x) {
21158 return (void *)((wxDC *) ((wxMemoryDC *) x));
21159 }
21160 static void *_p_wxWindowDCTo_p_wxDC(void *x) {
21161 return (void *)((wxDC *) ((wxWindowDC *) x));
21162 }
21163 static void *_p_wxMetaFileDCTo_p_wxDC(void *x) {
21164 return (void *)((wxDC *) ((wxMetaFileDC *) x));
21165 }
21166 static void *_p_wxBufferedPaintDCTo_p_wxDC(void *x) {
21167 return (void *)((wxDC *) (wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
21168 }
21169 static void *_p_wxClientDCTo_p_wxDC(void *x) {
21170 return (void *)((wxDC *) ((wxClientDC *) x));
21171 }
21172 static void *_p_wxPaintDCTo_p_wxDC(void *x) {
21173 return (void *)((wxDC *) ((wxPaintDC *) x));
21174 }
21175 static void *_p_wxPostScriptDCTo_p_wxDC(void *x) {
21176 return (void *)((wxDC *) ((wxPostScriptDC *) x));
21177 }
21178 static void *_p_wxPrinterDCTo_p_wxDC(void *x) {
21179 return (void *)((wxDC *) ((wxPrinterDC *) x));
21180 }
21181 static void *_p_wxBufferedPaintDCTo_p_wxBufferedDC(void *x) {
21182 return (void *)((wxBufferedDC *) ((wxBufferedPaintDC *) x));
21183 }
21184 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
21185 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
21186 }
21187 static void *_p_wxPenTo_p_wxObject(void *x) {
21188 return (void *)((wxObject *) (wxGDIObject *) ((wxPen *) x));
21189 }
21190 static void *_p_wxRegionIteratorTo_p_wxObject(void *x) {
21191 return (void *)((wxObject *) ((wxRegionIterator *) x));
21192 }
21193 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
21194 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
21195 }
21196 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
21197 return (void *)((wxObject *) ((wxSizerItem *) x));
21198 }
21199 static void *_p_wxColourDatabaseTo_p_wxObject(void *x) {
21200 return (void *)((wxObject *) ((wxColourDatabase *) x));
21201 }
21202 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
21203 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
21204 }
21205 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
21206 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
21207 }
21208 static void *_p_wxIconTo_p_wxObject(void *x) {
21209 return (void *)((wxObject *) (wxGDIObject *) ((wxIcon *) x));
21210 }
21211 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
21212 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
21213 }
21214 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
21215 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
21216 }
21217 static void *_p_wxSizerTo_p_wxObject(void *x) {
21218 return (void *)((wxObject *) ((wxSizer *) x));
21219 }
21220 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
21221 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
21222 }
21223 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
21224 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
21225 }
21226 static void *_p_wxPenListTo_p_wxObject(void *x) {
21227 return (void *)((wxObject *) ((wxPenList *) x));
21228 }
21229 static void *_p_wxEventTo_p_wxObject(void *x) {
21230 return (void *)((wxObject *) ((wxEvent *) x));
21231 }
21232 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
21233 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
21234 }
21235 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
21236 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
21237 }
21238 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
21239 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
21240 }
21241 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
21242 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
21243 }
21244 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
21245 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
21246 }
21247 static void *_p_wxDCTo_p_wxObject(void *x) {
21248 return (void *)((wxObject *) ((wxDC *) x));
21249 }
21250 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
21251 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
21252 }
21253 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
21254 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
21255 }
21256 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
21257 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21258 }
21259 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
21260 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
21261 }
21262 static void *_p_wxControlTo_p_wxObject(void *x) {
21263 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
21264 }
21265 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
21266 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
21267 }
21268 static void *_p_wxClientDCTo_p_wxObject(void *x) {
21269 return (void *)((wxObject *) (wxDC *) ((wxClientDC *) x));
21270 }
21271 static void *_p_wxFSFileTo_p_wxObject(void *x) {
21272 return (void *)((wxObject *) ((wxFSFile *) x));
21273 }
21274 static void *_p_wxMemoryDCTo_p_wxObject(void *x) {
21275 return (void *)((wxObject *) (wxDC *) ((wxMemoryDC *) x));
21276 }
21277 static void *_p_wxRegionTo_p_wxObject(void *x) {
21278 return (void *)((wxObject *) (wxGDIObject *) ((wxRegion *) x));
21279 }
21280 static void *_p_wxPySizerTo_p_wxObject(void *x) {
21281 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
21282 }
21283 static void *_p_wxWindowDCTo_p_wxObject(void *x) {
21284 return (void *)((wxObject *) (wxDC *) ((wxWindowDC *) x));
21285 }
21286 static void *_p_wxGDIObjectTo_p_wxObject(void *x) {
21287 return (void *)((wxObject *) ((wxGDIObject *) x));
21288 }
21289 static void *_p_wxEffectsTo_p_wxObject(void *x) {
21290 return (void *)((wxObject *) ((wxEffects *) x));
21291 }
21292 static void *_p_wxPyEventTo_p_wxObject(void *x) {
21293 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
21294 }
21295 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
21296 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
21297 }
21298 static void *_p_wxPostScriptDCTo_p_wxObject(void *x) {
21299 return (void *)((wxObject *) (wxDC *) ((wxPostScriptDC *) x));
21300 }
21301 static void *_p_wxShowEventTo_p_wxObject(void *x) {
21302 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
21303 }
21304 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
21305 return (void *)((wxObject *) ((wxMenuItem *) x));
21306 }
21307 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
21308 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
21309 }
21310 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
21311 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
21312 }
21313 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
21314 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
21315 }
21316 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
21317 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
21318 }
21319 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
21320 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
21321 }
21322 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
21323 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
21324 }
21325 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
21326 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
21327 }
21328 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
21329 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
21330 }
21331 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
21332 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
21333 }
21334 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
21335 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
21336 }
21337 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
21338 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
21339 }
21340 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
21341 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
21342 }
21343 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
21344 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
21345 }
21346 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
21347 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
21348 }
21349 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
21350 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
21351 }
21352 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
21353 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
21354 }
21355 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
21356 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
21357 }
21358 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
21359 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
21360 }
21361 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
21362 return (void *)((wxObject *) ((wxImageHandler *) x));
21363 }
21364 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
21365 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
21366 }
21367 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
21368 return (void *)((wxObject *) ((wxEvtHandler *) x));
21369 }
21370 static void *_p_wxBufferedPaintDCTo_p_wxObject(void *x) {
21371 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
21372 }
21373 static void *_p_wxPaintDCTo_p_wxObject(void *x) {
21374 return (void *)((wxObject *) (wxDC *) ((wxPaintDC *) x));
21375 }
21376 static void *_p_wxPrinterDCTo_p_wxObject(void *x) {
21377 return (void *)((wxObject *) (wxDC *) ((wxPrinterDC *) x));
21378 }
21379 static void *_p_wxScreenDCTo_p_wxObject(void *x) {
21380 return (void *)((wxObject *) (wxDC *) ((wxScreenDC *) x));
21381 }
21382 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
21383 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
21384 }
21385 static void *_p_wxImageTo_p_wxObject(void *x) {
21386 return (void *)((wxObject *) ((wxImage *) x));
21387 }
21388 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
21389 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
21390 }
21391 static void *_p_wxPaletteTo_p_wxObject(void *x) {
21392 return (void *)((wxObject *) (wxGDIObject *) ((wxPalette *) x));
21393 }
21394 static void *_p_wxBufferedDCTo_p_wxObject(void *x) {
21395 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *) ((wxBufferedDC *) x));
21396 }
21397 static void *_p_wxImageListTo_p_wxObject(void *x) {
21398 return (void *)((wxObject *) ((wxImageList *) x));
21399 }
21400 static void *_p_wxCursorTo_p_wxObject(void *x) {
21401 return (void *)((wxObject *) (wxGDIObject *) ((wxCursor *) x));
21402 }
21403 static void *_p_wxEncodingConverterTo_p_wxObject(void *x) {
21404 return (void *)((wxObject *) ((wxEncodingConverter *) x));
21405 }
21406 static void *_p_wxMirrorDCTo_p_wxObject(void *x) {
21407 return (void *)((wxObject *) (wxDC *) ((wxMirrorDC *) x));
21408 }
21409 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
21410 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21411 }
21412 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
21413 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
21414 }
21415 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
21416 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
21417 }
21418 static void *_p_wxWindowTo_p_wxObject(void *x) {
21419 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
21420 }
21421 static void *_p_wxMenuTo_p_wxObject(void *x) {
21422 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
21423 }
21424 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
21425 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
21426 }
21427 static void *_p_wxMetaFileDCTo_p_wxObject(void *x) {
21428 return (void *)((wxObject *) (wxDC *) ((wxMetaFileDC *) x));
21429 }
21430 static void *_p_wxBrushListTo_p_wxObject(void *x) {
21431 return (void *)((wxObject *) ((wxBrushList *) x));
21432 }
21433 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
21434 return (void *)((wxObject *) ((wxFileSystem *) x));
21435 }
21436 static void *_p_wxBitmapTo_p_wxObject(void *x) {
21437 return (void *)((wxObject *) (wxGDIObject *) ((wxBitmap *) x));
21438 }
21439 static void *_p_wxMaskTo_p_wxObject(void *x) {
21440 return (void *)((wxObject *) ((wxMask *) x));
21441 }
21442 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
21443 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
21444 }
21445 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
21446 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
21447 }
21448 static void *_p_wxPyAppTo_p_wxObject(void *x) {
21449 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
21450 }
21451 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
21452 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
21453 }
21454 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
21455 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
21456 }
21457 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
21458 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
21459 }
21460 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
21461 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
21462 }
21463 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
21464 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
21465 }
21466 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
21467 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
21468 }
21469 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
21470 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
21471 }
21472 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
21473 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
21474 }
21475 static void *_p_wxFontTo_p_wxObject(void *x) {
21476 return (void *)((wxObject *) (wxGDIObject *) ((wxFont *) x));
21477 }
21478 static void *_p_wxBrushTo_p_wxObject(void *x) {
21479 return (void *)((wxObject *) (wxGDIObject *) ((wxBrush *) x));
21480 }
21481 static void *_p_wxMetaFileTo_p_wxObject(void *x) {
21482 return (void *)((wxObject *) ((wxMetaFile *) x));
21483 }
21484 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
21485 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21486 }
21487 static void *_p_wxColourTo_p_wxObject(void *x) {
21488 return (void *)((wxObject *) ((wxColour *) x));
21489 }
21490 static void *_p_wxFontListTo_p_wxObject(void *x) {
21491 return (void *)((wxObject *) ((wxFontList *) x));
21492 }
21493 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
21494 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
21495 }
21496 static void *_p_wxValidatorTo_p_wxObject(void *x) {
21497 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
21498 }
21499 static void *_p_wxControlTo_p_wxWindow(void *x) {
21500 return (void *)((wxWindow *) ((wxControl *) x));
21501 }
21502 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
21503 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
21504 }
21505 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
21506 return (void *)((wxWindow *) ((wxMenuBar *) x));
21507 }
21508 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}};
21509 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}};
21510 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}};
21511 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}};
21512 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}};
21513 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}};
21514 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}};
21515 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}};
21516 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}};
21517 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}};
21518 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}};
21519 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}};
21520 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}};
21521 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}};
21522 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}};
21523 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}};
21524 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}};
21525 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}};
21526 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}};
21527 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}};
21528 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}};
21529 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}};
21530 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}};
21531 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}};
21532 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}};
21533 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}};
21534 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}};
21535 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}};
21536 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}};
21537 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}};
21538 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}};
21539 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}};
21540 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}};
21541 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}};
21542 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}};
21543 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}};
21544 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}};
21545 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}};
21546 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}};
21547 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}};
21548 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}};
21549 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}};
21550 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}};
21551 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}};
21552 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}};
21553 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}};
21554 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}};
21555 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}};
21556 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}};
21557 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}};
21558 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}};
21559 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}};
21560 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}};
21561 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}};
21562 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}};
21563 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}};
21564 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}};
21565 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}};
21566 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}};
21567 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}};
21568 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}};
21569 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}};
21570
21571 static swig_type_info *swig_types_initial[] = {
21572 _swigt__p_wxPostScriptDC,
21573 _swigt__p_wxBrush,
21574 _swigt__p_wxColour,
21575 _swigt__p_wxDC,
21576 _swigt__p_wxMirrorDC,
21577 _swigt__p_form_ops_t,
21578 _swigt__p_wxDuplexMode,
21579 _swigt__p_wxPyFontEnumerator,
21580 _swigt__p_char,
21581 _swigt__p_wxIconLocation,
21582 _swigt__p_wxImage,
21583 _swigt__p_wxMetaFileDC,
21584 _swigt__p_wxMask,
21585 _swigt__p_wxSize,
21586 _swigt__p_wxFont,
21587 _swigt__p_wxWindow,
21588 _swigt__p_double,
21589 _swigt__p_wxMemoryDC,
21590 _swigt__p_wxFontMapper,
21591 _swigt__p_wxEffects,
21592 _swigt__p_wxNativeEncodingInfo,
21593 _swigt__p_wxPalette,
21594 _swigt__p_wxBitmap,
21595 _swigt__p_wxObject,
21596 _swigt__p_wxRegionIterator,
21597 _swigt__p_wxRect,
21598 _swigt__p_wxPaperSize,
21599 _swigt__p_wxString,
21600 _swigt__unsigned_int,
21601 _swigt__p_unsigned_int,
21602 _swigt__p_wxPrinterDC,
21603 _swigt__p_wxIconBundle,
21604 _swigt__p_wxPoint,
21605 _swigt__p_wxDash,
21606 _swigt__p_wxScreenDC,
21607 _swigt__p_wxCursor,
21608 _swigt__p_wxClientDC,
21609 _swigt__p_wxBufferedDC,
21610 _swigt__p_wxImageList,
21611 _swigt__p_unsigned_char,
21612 _swigt__p_wxGDIObject,
21613 _swigt__p_wxIcon,
21614 _swigt__p_wxLocale,
21615 _swigt__ptrdiff_t,
21616 _swigt__std__ptrdiff_t,
21617 _swigt__p_wxRegion,
21618 _swigt__p_wxConfigBase,
21619 _swigt__p_wxLanguageInfo,
21620 _swigt__p_wxWindowDC,
21621 _swigt__p_wxPrintData,
21622 _swigt__p_wxBrushList,
21623 _swigt__p_wxFontList,
21624 _swigt__p_wxPen,
21625 _swigt__p_wxBufferedPaintDC,
21626 _swigt__p_wxPaintDC,
21627 _swigt__p_wxPenList,
21628 _swigt__p_int,
21629 _swigt__p_wxMetaFile,
21630 _swigt__p_unsigned_long,
21631 _swigt__p_wxNativeFontInfo,
21632 _swigt__p_wxEncodingConverter,
21633 _swigt__p_wxColourDatabase,
21634 0
21635 };
21636
21637
21638 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
21639
21640 static swig_const_info swig_const_table[] = {
21641 {0, 0, 0, 0.0, 0, 0}};
21642
21643 #ifdef __cplusplus
21644 }
21645 #endif
21646
21647
21648 #ifdef __cplusplus
21649 extern "C" {
21650 #endif
21651
21652 /* Python-specific SWIG API */
21653 #define SWIG_newvarlink() SWIG_Python_newvarlink()
21654 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
21655 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
21656
21657 /* -----------------------------------------------------------------------------
21658 * global variable support code.
21659 * ----------------------------------------------------------------------------- */
21660
21661 typedef struct swig_globalvar {
21662 char *name; /* Name of global variable */
21663 PyObject *(*get_attr)(); /* Return the current value */
21664 int (*set_attr)(PyObject *); /* Set the value */
21665 struct swig_globalvar *next;
21666 } swig_globalvar;
21667
21668 typedef struct swig_varlinkobject {
21669 PyObject_HEAD
21670 swig_globalvar *vars;
21671 } swig_varlinkobject;
21672
21673 static PyObject *
21674 swig_varlink_repr(swig_varlinkobject *v) {
21675 v = v;
21676 return PyString_FromString("<Swig global variables>");
21677 }
21678
21679 static int
21680 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
21681 swig_globalvar *var;
21682 flags = flags;
21683 fprintf(fp,"Swig global variables { ");
21684 for (var = v->vars; var; var=var->next) {
21685 fprintf(fp,"%s", var->name);
21686 if (var->next) fprintf(fp,", ");
21687 }
21688 fprintf(fp," }\n");
21689 return 0;
21690 }
21691
21692 static PyObject *
21693 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
21694 swig_globalvar *var = v->vars;
21695 while (var) {
21696 if (strcmp(var->name,n) == 0) {
21697 return (*var->get_attr)();
21698 }
21699 var = var->next;
21700 }
21701 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
21702 return NULL;
21703 }
21704
21705 static int
21706 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
21707 swig_globalvar *var = v->vars;
21708 while (var) {
21709 if (strcmp(var->name,n) == 0) {
21710 return (*var->set_attr)(p);
21711 }
21712 var = var->next;
21713 }
21714 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
21715 return 1;
21716 }
21717
21718 static PyTypeObject varlinktype = {
21719 PyObject_HEAD_INIT(0)
21720 0, /* Number of items in variable part (ob_size) */
21721 (char *)"swigvarlink", /* Type name (tp_name) */
21722 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
21723 0, /* Itemsize (tp_itemsize) */
21724 0, /* Deallocator (tp_dealloc) */
21725 (printfunc) swig_varlink_print, /* Print (tp_print) */
21726 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
21727 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
21728 0, /* tp_compare */
21729 (reprfunc) swig_varlink_repr, /* tp_repr */
21730 0, /* tp_as_number */
21731 0, /* tp_as_sequence */
21732 0, /* tp_as_mapping */
21733 0, /* tp_hash */
21734 0, /* tp_call */
21735 0, /* tp_str */
21736 0, /* tp_getattro */
21737 0, /* tp_setattro */
21738 0, /* tp_as_buffer */
21739 0, /* tp_flags */
21740 0, /* tp_doc */
21741 #if PY_VERSION_HEX >= 0x02000000
21742 0, /* tp_traverse */
21743 0, /* tp_clear */
21744 #endif
21745 #if PY_VERSION_HEX >= 0x02010000
21746 0, /* tp_richcompare */
21747 0, /* tp_weaklistoffset */
21748 #endif
21749 #if PY_VERSION_HEX >= 0x02020000
21750 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
21751 #endif
21752 #if PY_VERSION_HEX >= 0x02030000
21753 0, /* tp_del */
21754 #endif
21755 #ifdef COUNT_ALLOCS
21756 0,0,0,0 /* tp_alloc -> tp_next */
21757 #endif
21758 };
21759
21760 /* Create a variable linking object for use later */
21761 static PyObject *
21762 SWIG_Python_newvarlink(void) {
21763 swig_varlinkobject *result = 0;
21764 result = PyMem_NEW(swig_varlinkobject,1);
21765 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
21766 result->ob_type = &varlinktype;
21767 result->vars = 0;
21768 result->ob_refcnt = 0;
21769 Py_XINCREF((PyObject *) result);
21770 return ((PyObject*) result);
21771 }
21772
21773 static void
21774 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
21775 swig_varlinkobject *v;
21776 swig_globalvar *gv;
21777 v= (swig_varlinkobject *) p;
21778 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
21779 gv->name = (char *) malloc(strlen(name)+1);
21780 strcpy(gv->name,name);
21781 gv->get_attr = get_attr;
21782 gv->set_attr = set_attr;
21783 gv->next = v->vars;
21784 v->vars = gv;
21785 }
21786
21787 /* -----------------------------------------------------------------------------
21788 * constants/methods manipulation
21789 * ----------------------------------------------------------------------------- */
21790
21791 /* Install Constants */
21792 static void
21793 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
21794 PyObject *obj = 0;
21795 size_t i;
21796 for (i = 0; constants[i].type; i++) {
21797 switch(constants[i].type) {
21798 case SWIG_PY_INT:
21799 obj = PyInt_FromLong(constants[i].lvalue);
21800 break;
21801 case SWIG_PY_FLOAT:
21802 obj = PyFloat_FromDouble(constants[i].dvalue);
21803 break;
21804 case SWIG_PY_STRING:
21805 if (constants[i].pvalue) {
21806 obj = PyString_FromString((char *) constants[i].pvalue);
21807 } else {
21808 Py_INCREF(Py_None);
21809 obj = Py_None;
21810 }
21811 break;
21812 case SWIG_PY_POINTER:
21813 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
21814 break;
21815 case SWIG_PY_BINARY:
21816 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
21817 break;
21818 default:
21819 obj = 0;
21820 break;
21821 }
21822 if (obj) {
21823 PyDict_SetItemString(d,constants[i].name,obj);
21824 Py_DECREF(obj);
21825 }
21826 }
21827 }
21828
21829 /* -----------------------------------------------------------------------------*/
21830 /* Fix SwigMethods to carry the callback ptrs when needed */
21831 /* -----------------------------------------------------------------------------*/
21832
21833 static void
21834 SWIG_Python_FixMethods(PyMethodDef *methods,
21835 swig_const_info *const_table,
21836 swig_type_info **types,
21837 swig_type_info **types_initial) {
21838 size_t i;
21839 for (i = 0; methods[i].ml_name; ++i) {
21840 char *c = methods[i].ml_doc;
21841 if (c && (c = strstr(c, "swig_ptr: "))) {
21842 int j;
21843 swig_const_info *ci = 0;
21844 char *name = c + 10;
21845 for (j = 0; const_table[j].type; j++) {
21846 if (strncmp(const_table[j].name, name,
21847 strlen(const_table[j].name)) == 0) {
21848 ci = &(const_table[j]);
21849 break;
21850 }
21851 }
21852 if (ci) {
21853 size_t shift = (ci->ptype) - types;
21854 swig_type_info *ty = types_initial[shift];
21855 size_t ldoc = (c - methods[i].ml_doc);
21856 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
21857 char *ndoc = (char*)malloc(ldoc + lptr + 10);
21858 char *buff = ndoc;
21859 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
21860 strncpy(buff, methods[i].ml_doc, ldoc);
21861 buff += ldoc;
21862 strncpy(buff, "swig_ptr: ", 10);
21863 buff += 10;
21864 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
21865 methods[i].ml_doc = ndoc;
21866 }
21867 }
21868 }
21869 }
21870
21871 /* -----------------------------------------------------------------------------*
21872 * Initialize type list
21873 * -----------------------------------------------------------------------------*/
21874
21875 #if PY_MAJOR_VERSION < 2
21876 /* PyModule_AddObject function was introduced in Python 2.0. The following function
21877 is copied out of Python/modsupport.c in python version 2.3.4 */
21878 static int
21879 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
21880 {
21881 PyObject *dict;
21882 if (!PyModule_Check(m)) {
21883 PyErr_SetString(PyExc_TypeError,
21884 "PyModule_AddObject() needs module as first arg");
21885 return -1;
21886 }
21887 if (!o) {
21888 PyErr_SetString(PyExc_TypeError,
21889 "PyModule_AddObject() needs non-NULL value");
21890 return -1;
21891 }
21892
21893 dict = PyModule_GetDict(m);
21894 if (dict == NULL) {
21895 /* Internal error -- modules must have a dict! */
21896 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
21897 PyModule_GetName(m));
21898 return -1;
21899 }
21900 if (PyDict_SetItemString(dict, name, o))
21901 return -1;
21902 Py_DECREF(o);
21903 return 0;
21904 }
21905 #endif
21906
21907 static swig_type_info **
21908 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
21909 static PyMethodDef swig_empty_runtime_method_table[] = {
21910 {
21911 NULL, NULL, 0, NULL
21912 }
21913 };/* Sentinel */
21914
21915 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
21916 swig_empty_runtime_method_table);
21917 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
21918 if (pointer && module) {
21919 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
21920 }
21921 return type_list_handle;
21922 }
21923
21924 static swig_type_info **
21925 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
21926 swig_type_info **type_pointer;
21927
21928 /* first check if module already created */
21929 type_pointer = SWIG_Python_GetTypeListHandle();
21930 if (type_pointer) {
21931 return type_pointer;
21932 } else {
21933 /* create a new module and variable */
21934 return SWIG_Python_SetTypeListHandle(type_list_handle);
21935 }
21936 }
21937
21938 #ifdef __cplusplus
21939 }
21940 #endif
21941
21942 /* -----------------------------------------------------------------------------*
21943 * Partial Init method
21944 * -----------------------------------------------------------------------------*/
21945
21946 #ifdef SWIG_LINK_RUNTIME
21947 #ifdef __cplusplus
21948 extern "C"
21949 #endif
21950 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
21951 #endif
21952
21953 #ifdef __cplusplus
21954 extern "C"
21955 #endif
21956 SWIGEXPORT(void) SWIG_init(void) {
21957 static PyObject *SWIG_globals = 0;
21958 static int typeinit = 0;
21959 PyObject *m, *d;
21960 int i;
21961 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
21962
21963 /* Fix SwigMethods to carry the callback ptrs when needed */
21964 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
21965
21966 m = Py_InitModule((char *) SWIG_name, SwigMethods);
21967 d = PyModule_GetDict(m);
21968
21969 if (!typeinit) {
21970 #ifdef SWIG_LINK_RUNTIME
21971 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
21972 #else
21973 # ifndef SWIG_STATIC_RUNTIME
21974 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
21975 # endif
21976 #endif
21977 for (i = 0; swig_types_initial[i]; i++) {
21978 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
21979 }
21980 typeinit = 1;
21981 }
21982 SWIG_InstallConstants(d,swig_const_table);
21983
21984 {
21985 PyDict_SetItemString(d,"OutRegion", SWIG_From_int((int)(wxOutRegion)));
21986 }
21987 {
21988 PyDict_SetItemString(d,"PartRegion", SWIG_From_int((int)(wxPartRegion)));
21989 }
21990 {
21991 PyDict_SetItemString(d,"InRegion", SWIG_From_int((int)(wxInRegion)));
21992 }
21993 {
21994 PyDict_SetItemString(d,"FONTFAMILY_DEFAULT", SWIG_From_int((int)(wxFONTFAMILY_DEFAULT)));
21995 }
21996 {
21997 PyDict_SetItemString(d,"FONTFAMILY_DECORATIVE", SWIG_From_int((int)(wxFONTFAMILY_DECORATIVE)));
21998 }
21999 {
22000 PyDict_SetItemString(d,"FONTFAMILY_ROMAN", SWIG_From_int((int)(wxFONTFAMILY_ROMAN)));
22001 }
22002 {
22003 PyDict_SetItemString(d,"FONTFAMILY_SCRIPT", SWIG_From_int((int)(wxFONTFAMILY_SCRIPT)));
22004 }
22005 {
22006 PyDict_SetItemString(d,"FONTFAMILY_SWISS", SWIG_From_int((int)(wxFONTFAMILY_SWISS)));
22007 }
22008 {
22009 PyDict_SetItemString(d,"FONTFAMILY_MODERN", SWIG_From_int((int)(wxFONTFAMILY_MODERN)));
22010 }
22011 {
22012 PyDict_SetItemString(d,"FONTFAMILY_TELETYPE", SWIG_From_int((int)(wxFONTFAMILY_TELETYPE)));
22013 }
22014 {
22015 PyDict_SetItemString(d,"FONTFAMILY_MAX", SWIG_From_int((int)(wxFONTFAMILY_MAX)));
22016 }
22017 {
22018 PyDict_SetItemString(d,"FONTFAMILY_UNKNOWN", SWIG_From_int((int)(wxFONTFAMILY_UNKNOWN)));
22019 }
22020 {
22021 PyDict_SetItemString(d,"FONTSTYLE_NORMAL", SWIG_From_int((int)(wxFONTSTYLE_NORMAL)));
22022 }
22023 {
22024 PyDict_SetItemString(d,"FONTSTYLE_ITALIC", SWIG_From_int((int)(wxFONTSTYLE_ITALIC)));
22025 }
22026 {
22027 PyDict_SetItemString(d,"FONTSTYLE_SLANT", SWIG_From_int((int)(wxFONTSTYLE_SLANT)));
22028 }
22029 {
22030 PyDict_SetItemString(d,"FONTSTYLE_MAX", SWIG_From_int((int)(wxFONTSTYLE_MAX)));
22031 }
22032 {
22033 PyDict_SetItemString(d,"FONTWEIGHT_NORMAL", SWIG_From_int((int)(wxFONTWEIGHT_NORMAL)));
22034 }
22035 {
22036 PyDict_SetItemString(d,"FONTWEIGHT_LIGHT", SWIG_From_int((int)(wxFONTWEIGHT_LIGHT)));
22037 }
22038 {
22039 PyDict_SetItemString(d,"FONTWEIGHT_BOLD", SWIG_From_int((int)(wxFONTWEIGHT_BOLD)));
22040 }
22041 {
22042 PyDict_SetItemString(d,"FONTWEIGHT_MAX", SWIG_From_int((int)(wxFONTWEIGHT_MAX)));
22043 }
22044 {
22045 PyDict_SetItemString(d,"FONTFLAG_DEFAULT", SWIG_From_int((int)(wxFONTFLAG_DEFAULT)));
22046 }
22047 {
22048 PyDict_SetItemString(d,"FONTFLAG_ITALIC", SWIG_From_int((int)(wxFONTFLAG_ITALIC)));
22049 }
22050 {
22051 PyDict_SetItemString(d,"FONTFLAG_SLANT", SWIG_From_int((int)(wxFONTFLAG_SLANT)));
22052 }
22053 {
22054 PyDict_SetItemString(d,"FONTFLAG_LIGHT", SWIG_From_int((int)(wxFONTFLAG_LIGHT)));
22055 }
22056 {
22057 PyDict_SetItemString(d,"FONTFLAG_BOLD", SWIG_From_int((int)(wxFONTFLAG_BOLD)));
22058 }
22059 {
22060 PyDict_SetItemString(d,"FONTFLAG_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_ANTIALIASED)));
22061 }
22062 {
22063 PyDict_SetItemString(d,"FONTFLAG_NOT_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_NOT_ANTIALIASED)));
22064 }
22065 {
22066 PyDict_SetItemString(d,"FONTFLAG_UNDERLINED", SWIG_From_int((int)(wxFONTFLAG_UNDERLINED)));
22067 }
22068 {
22069 PyDict_SetItemString(d,"FONTFLAG_STRIKETHROUGH", SWIG_From_int((int)(wxFONTFLAG_STRIKETHROUGH)));
22070 }
22071 {
22072 PyDict_SetItemString(d,"FONTFLAG_MASK", SWIG_From_int((int)(wxFONTFLAG_MASK)));
22073 }
22074 {
22075 PyDict_SetItemString(d,"FONTENCODING_SYSTEM", SWIG_From_int((int)(wxFONTENCODING_SYSTEM)));
22076 }
22077 {
22078 PyDict_SetItemString(d,"FONTENCODING_DEFAULT", SWIG_From_int((int)(wxFONTENCODING_DEFAULT)));
22079 }
22080 {
22081 PyDict_SetItemString(d,"FONTENCODING_ISO8859_1", SWIG_From_int((int)(wxFONTENCODING_ISO8859_1)));
22082 }
22083 {
22084 PyDict_SetItemString(d,"FONTENCODING_ISO8859_2", SWIG_From_int((int)(wxFONTENCODING_ISO8859_2)));
22085 }
22086 {
22087 PyDict_SetItemString(d,"FONTENCODING_ISO8859_3", SWIG_From_int((int)(wxFONTENCODING_ISO8859_3)));
22088 }
22089 {
22090 PyDict_SetItemString(d,"FONTENCODING_ISO8859_4", SWIG_From_int((int)(wxFONTENCODING_ISO8859_4)));
22091 }
22092 {
22093 PyDict_SetItemString(d,"FONTENCODING_ISO8859_5", SWIG_From_int((int)(wxFONTENCODING_ISO8859_5)));
22094 }
22095 {
22096 PyDict_SetItemString(d,"FONTENCODING_ISO8859_6", SWIG_From_int((int)(wxFONTENCODING_ISO8859_6)));
22097 }
22098 {
22099 PyDict_SetItemString(d,"FONTENCODING_ISO8859_7", SWIG_From_int((int)(wxFONTENCODING_ISO8859_7)));
22100 }
22101 {
22102 PyDict_SetItemString(d,"FONTENCODING_ISO8859_8", SWIG_From_int((int)(wxFONTENCODING_ISO8859_8)));
22103 }
22104 {
22105 PyDict_SetItemString(d,"FONTENCODING_ISO8859_9", SWIG_From_int((int)(wxFONTENCODING_ISO8859_9)));
22106 }
22107 {
22108 PyDict_SetItemString(d,"FONTENCODING_ISO8859_10", SWIG_From_int((int)(wxFONTENCODING_ISO8859_10)));
22109 }
22110 {
22111 PyDict_SetItemString(d,"FONTENCODING_ISO8859_11", SWIG_From_int((int)(wxFONTENCODING_ISO8859_11)));
22112 }
22113 {
22114 PyDict_SetItemString(d,"FONTENCODING_ISO8859_12", SWIG_From_int((int)(wxFONTENCODING_ISO8859_12)));
22115 }
22116 {
22117 PyDict_SetItemString(d,"FONTENCODING_ISO8859_13", SWIG_From_int((int)(wxFONTENCODING_ISO8859_13)));
22118 }
22119 {
22120 PyDict_SetItemString(d,"FONTENCODING_ISO8859_14", SWIG_From_int((int)(wxFONTENCODING_ISO8859_14)));
22121 }
22122 {
22123 PyDict_SetItemString(d,"FONTENCODING_ISO8859_15", SWIG_From_int((int)(wxFONTENCODING_ISO8859_15)));
22124 }
22125 {
22126 PyDict_SetItemString(d,"FONTENCODING_ISO8859_MAX", SWIG_From_int((int)(wxFONTENCODING_ISO8859_MAX)));
22127 }
22128 {
22129 PyDict_SetItemString(d,"FONTENCODING_KOI8", SWIG_From_int((int)(wxFONTENCODING_KOI8)));
22130 }
22131 {
22132 PyDict_SetItemString(d,"FONTENCODING_KOI8_U", SWIG_From_int((int)(wxFONTENCODING_KOI8_U)));
22133 }
22134 {
22135 PyDict_SetItemString(d,"FONTENCODING_ALTERNATIVE", SWIG_From_int((int)(wxFONTENCODING_ALTERNATIVE)));
22136 }
22137 {
22138 PyDict_SetItemString(d,"FONTENCODING_BULGARIAN", SWIG_From_int((int)(wxFONTENCODING_BULGARIAN)));
22139 }
22140 {
22141 PyDict_SetItemString(d,"FONTENCODING_CP437", SWIG_From_int((int)(wxFONTENCODING_CP437)));
22142 }
22143 {
22144 PyDict_SetItemString(d,"FONTENCODING_CP850", SWIG_From_int((int)(wxFONTENCODING_CP850)));
22145 }
22146 {
22147 PyDict_SetItemString(d,"FONTENCODING_CP852", SWIG_From_int((int)(wxFONTENCODING_CP852)));
22148 }
22149 {
22150 PyDict_SetItemString(d,"FONTENCODING_CP855", SWIG_From_int((int)(wxFONTENCODING_CP855)));
22151 }
22152 {
22153 PyDict_SetItemString(d,"FONTENCODING_CP866", SWIG_From_int((int)(wxFONTENCODING_CP866)));
22154 }
22155 {
22156 PyDict_SetItemString(d,"FONTENCODING_CP874", SWIG_From_int((int)(wxFONTENCODING_CP874)));
22157 }
22158 {
22159 PyDict_SetItemString(d,"FONTENCODING_CP932", SWIG_From_int((int)(wxFONTENCODING_CP932)));
22160 }
22161 {
22162 PyDict_SetItemString(d,"FONTENCODING_CP936", SWIG_From_int((int)(wxFONTENCODING_CP936)));
22163 }
22164 {
22165 PyDict_SetItemString(d,"FONTENCODING_CP949", SWIG_From_int((int)(wxFONTENCODING_CP949)));
22166 }
22167 {
22168 PyDict_SetItemString(d,"FONTENCODING_CP950", SWIG_From_int((int)(wxFONTENCODING_CP950)));
22169 }
22170 {
22171 PyDict_SetItemString(d,"FONTENCODING_CP1250", SWIG_From_int((int)(wxFONTENCODING_CP1250)));
22172 }
22173 {
22174 PyDict_SetItemString(d,"FONTENCODING_CP1251", SWIG_From_int((int)(wxFONTENCODING_CP1251)));
22175 }
22176 {
22177 PyDict_SetItemString(d,"FONTENCODING_CP1252", SWIG_From_int((int)(wxFONTENCODING_CP1252)));
22178 }
22179 {
22180 PyDict_SetItemString(d,"FONTENCODING_CP1253", SWIG_From_int((int)(wxFONTENCODING_CP1253)));
22181 }
22182 {
22183 PyDict_SetItemString(d,"FONTENCODING_CP1254", SWIG_From_int((int)(wxFONTENCODING_CP1254)));
22184 }
22185 {
22186 PyDict_SetItemString(d,"FONTENCODING_CP1255", SWIG_From_int((int)(wxFONTENCODING_CP1255)));
22187 }
22188 {
22189 PyDict_SetItemString(d,"FONTENCODING_CP1256", SWIG_From_int((int)(wxFONTENCODING_CP1256)));
22190 }
22191 {
22192 PyDict_SetItemString(d,"FONTENCODING_CP1257", SWIG_From_int((int)(wxFONTENCODING_CP1257)));
22193 }
22194 {
22195 PyDict_SetItemString(d,"FONTENCODING_CP12_MAX", SWIG_From_int((int)(wxFONTENCODING_CP12_MAX)));
22196 }
22197 {
22198 PyDict_SetItemString(d,"FONTENCODING_UTF7", SWIG_From_int((int)(wxFONTENCODING_UTF7)));
22199 }
22200 {
22201 PyDict_SetItemString(d,"FONTENCODING_UTF8", SWIG_From_int((int)(wxFONTENCODING_UTF8)));
22202 }
22203 {
22204 PyDict_SetItemString(d,"FONTENCODING_EUC_JP", SWIG_From_int((int)(wxFONTENCODING_EUC_JP)));
22205 }
22206 {
22207 PyDict_SetItemString(d,"FONTENCODING_UTF16BE", SWIG_From_int((int)(wxFONTENCODING_UTF16BE)));
22208 }
22209 {
22210 PyDict_SetItemString(d,"FONTENCODING_UTF16LE", SWIG_From_int((int)(wxFONTENCODING_UTF16LE)));
22211 }
22212 {
22213 PyDict_SetItemString(d,"FONTENCODING_UTF32BE", SWIG_From_int((int)(wxFONTENCODING_UTF32BE)));
22214 }
22215 {
22216 PyDict_SetItemString(d,"FONTENCODING_UTF32LE", SWIG_From_int((int)(wxFONTENCODING_UTF32LE)));
22217 }
22218 {
22219 PyDict_SetItemString(d,"FONTENCODING_MACROMAN", SWIG_From_int((int)(wxFONTENCODING_MACROMAN)));
22220 }
22221 {
22222 PyDict_SetItemString(d,"FONTENCODING_MACJAPANESE", SWIG_From_int((int)(wxFONTENCODING_MACJAPANESE)));
22223 }
22224 {
22225 PyDict_SetItemString(d,"FONTENCODING_MACCHINESETRAD", SWIG_From_int((int)(wxFONTENCODING_MACCHINESETRAD)));
22226 }
22227 {
22228 PyDict_SetItemString(d,"FONTENCODING_MACKOREAN", SWIG_From_int((int)(wxFONTENCODING_MACKOREAN)));
22229 }
22230 {
22231 PyDict_SetItemString(d,"FONTENCODING_MACARABIC", SWIG_From_int((int)(wxFONTENCODING_MACARABIC)));
22232 }
22233 {
22234 PyDict_SetItemString(d,"FONTENCODING_MACHEBREW", SWIG_From_int((int)(wxFONTENCODING_MACHEBREW)));
22235 }
22236 {
22237 PyDict_SetItemString(d,"FONTENCODING_MACGREEK", SWIG_From_int((int)(wxFONTENCODING_MACGREEK)));
22238 }
22239 {
22240 PyDict_SetItemString(d,"FONTENCODING_MACCYRILLIC", SWIG_From_int((int)(wxFONTENCODING_MACCYRILLIC)));
22241 }
22242 {
22243 PyDict_SetItemString(d,"FONTENCODING_MACDEVANAGARI", SWIG_From_int((int)(wxFONTENCODING_MACDEVANAGARI)));
22244 }
22245 {
22246 PyDict_SetItemString(d,"FONTENCODING_MACGURMUKHI", SWIG_From_int((int)(wxFONTENCODING_MACGURMUKHI)));
22247 }
22248 {
22249 PyDict_SetItemString(d,"FONTENCODING_MACGUJARATI", SWIG_From_int((int)(wxFONTENCODING_MACGUJARATI)));
22250 }
22251 {
22252 PyDict_SetItemString(d,"FONTENCODING_MACORIYA", SWIG_From_int((int)(wxFONTENCODING_MACORIYA)));
22253 }
22254 {
22255 PyDict_SetItemString(d,"FONTENCODING_MACBENGALI", SWIG_From_int((int)(wxFONTENCODING_MACBENGALI)));
22256 }
22257 {
22258 PyDict_SetItemString(d,"FONTENCODING_MACTAMIL", SWIG_From_int((int)(wxFONTENCODING_MACTAMIL)));
22259 }
22260 {
22261 PyDict_SetItemString(d,"FONTENCODING_MACTELUGU", SWIG_From_int((int)(wxFONTENCODING_MACTELUGU)));
22262 }
22263 {
22264 PyDict_SetItemString(d,"FONTENCODING_MACKANNADA", SWIG_From_int((int)(wxFONTENCODING_MACKANNADA)));
22265 }
22266 {
22267 PyDict_SetItemString(d,"FONTENCODING_MACMALAJALAM", SWIG_From_int((int)(wxFONTENCODING_MACMALAJALAM)));
22268 }
22269 {
22270 PyDict_SetItemString(d,"FONTENCODING_MACSINHALESE", SWIG_From_int((int)(wxFONTENCODING_MACSINHALESE)));
22271 }
22272 {
22273 PyDict_SetItemString(d,"FONTENCODING_MACBURMESE", SWIG_From_int((int)(wxFONTENCODING_MACBURMESE)));
22274 }
22275 {
22276 PyDict_SetItemString(d,"FONTENCODING_MACKHMER", SWIG_From_int((int)(wxFONTENCODING_MACKHMER)));
22277 }
22278 {
22279 PyDict_SetItemString(d,"FONTENCODING_MACTHAI", SWIG_From_int((int)(wxFONTENCODING_MACTHAI)));
22280 }
22281 {
22282 PyDict_SetItemString(d,"FONTENCODING_MACLAOTIAN", SWIG_From_int((int)(wxFONTENCODING_MACLAOTIAN)));
22283 }
22284 {
22285 PyDict_SetItemString(d,"FONTENCODING_MACGEORGIAN", SWIG_From_int((int)(wxFONTENCODING_MACGEORGIAN)));
22286 }
22287 {
22288 PyDict_SetItemString(d,"FONTENCODING_MACARMENIAN", SWIG_From_int((int)(wxFONTENCODING_MACARMENIAN)));
22289 }
22290 {
22291 PyDict_SetItemString(d,"FONTENCODING_MACCHINESESIMP", SWIG_From_int((int)(wxFONTENCODING_MACCHINESESIMP)));
22292 }
22293 {
22294 PyDict_SetItemString(d,"FONTENCODING_MACTIBETAN", SWIG_From_int((int)(wxFONTENCODING_MACTIBETAN)));
22295 }
22296 {
22297 PyDict_SetItemString(d,"FONTENCODING_MACMONGOLIAN", SWIG_From_int((int)(wxFONTENCODING_MACMONGOLIAN)));
22298 }
22299 {
22300 PyDict_SetItemString(d,"FONTENCODING_MACETHIOPIC", SWIG_From_int((int)(wxFONTENCODING_MACETHIOPIC)));
22301 }
22302 {
22303 PyDict_SetItemString(d,"FONTENCODING_MACCENTRALEUR", SWIG_From_int((int)(wxFONTENCODING_MACCENTRALEUR)));
22304 }
22305 {
22306 PyDict_SetItemString(d,"FONTENCODING_MACVIATNAMESE", SWIG_From_int((int)(wxFONTENCODING_MACVIATNAMESE)));
22307 }
22308 {
22309 PyDict_SetItemString(d,"FONTENCODING_MACARABICEXT", SWIG_From_int((int)(wxFONTENCODING_MACARABICEXT)));
22310 }
22311 {
22312 PyDict_SetItemString(d,"FONTENCODING_MACSYMBOL", SWIG_From_int((int)(wxFONTENCODING_MACSYMBOL)));
22313 }
22314 {
22315 PyDict_SetItemString(d,"FONTENCODING_MACDINGBATS", SWIG_From_int((int)(wxFONTENCODING_MACDINGBATS)));
22316 }
22317 {
22318 PyDict_SetItemString(d,"FONTENCODING_MACTURKISH", SWIG_From_int((int)(wxFONTENCODING_MACTURKISH)));
22319 }
22320 {
22321 PyDict_SetItemString(d,"FONTENCODING_MACCROATIAN", SWIG_From_int((int)(wxFONTENCODING_MACCROATIAN)));
22322 }
22323 {
22324 PyDict_SetItemString(d,"FONTENCODING_MACICELANDIC", SWIG_From_int((int)(wxFONTENCODING_MACICELANDIC)));
22325 }
22326 {
22327 PyDict_SetItemString(d,"FONTENCODING_MACROMANIAN", SWIG_From_int((int)(wxFONTENCODING_MACROMANIAN)));
22328 }
22329 {
22330 PyDict_SetItemString(d,"FONTENCODING_MACCELTIC", SWIG_From_int((int)(wxFONTENCODING_MACCELTIC)));
22331 }
22332 {
22333 PyDict_SetItemString(d,"FONTENCODING_MACGAELIC", SWIG_From_int((int)(wxFONTENCODING_MACGAELIC)));
22334 }
22335 {
22336 PyDict_SetItemString(d,"FONTENCODING_MACKEYBOARD", SWIG_From_int((int)(wxFONTENCODING_MACKEYBOARD)));
22337 }
22338 {
22339 PyDict_SetItemString(d,"FONTENCODING_MACMIN", SWIG_From_int((int)(wxFONTENCODING_MACMIN)));
22340 }
22341 {
22342 PyDict_SetItemString(d,"FONTENCODING_MACMAX", SWIG_From_int((int)(wxFONTENCODING_MACMAX)));
22343 }
22344 {
22345 PyDict_SetItemString(d,"FONTENCODING_MAX", SWIG_From_int((int)(wxFONTENCODING_MAX)));
22346 }
22347 {
22348 PyDict_SetItemString(d,"FONTENCODING_UTF16", SWIG_From_int((int)(wxFONTENCODING_UTF16)));
22349 }
22350 {
22351 PyDict_SetItemString(d,"FONTENCODING_UTF32", SWIG_From_int((int)(wxFONTENCODING_UTF32)));
22352 }
22353 {
22354 PyDict_SetItemString(d,"FONTENCODING_UNICODE", SWIG_From_int((int)(wxFONTENCODING_UNICODE)));
22355 }
22356 {
22357 PyDict_SetItemString(d,"FONTENCODING_GB2312", SWIG_From_int((int)(wxFONTENCODING_GB2312)));
22358 }
22359 {
22360 PyDict_SetItemString(d,"FONTENCODING_BIG5", SWIG_From_int((int)(wxFONTENCODING_BIG5)));
22361 }
22362 {
22363 PyDict_SetItemString(d,"FONTENCODING_SHIFT_JIS", SWIG_From_int((int)(wxFONTENCODING_SHIFT_JIS)));
22364 }
22365
22366 wxPyPtrTypeMap_Add("wxFontEnumerator", "wxPyFontEnumerator");
22367
22368 {
22369 PyDict_SetItemString(d,"LANGUAGE_DEFAULT", SWIG_From_int((int)(wxLANGUAGE_DEFAULT)));
22370 }
22371 {
22372 PyDict_SetItemString(d,"LANGUAGE_UNKNOWN", SWIG_From_int((int)(wxLANGUAGE_UNKNOWN)));
22373 }
22374 {
22375 PyDict_SetItemString(d,"LANGUAGE_ABKHAZIAN", SWIG_From_int((int)(wxLANGUAGE_ABKHAZIAN)));
22376 }
22377 {
22378 PyDict_SetItemString(d,"LANGUAGE_AFAR", SWIG_From_int((int)(wxLANGUAGE_AFAR)));
22379 }
22380 {
22381 PyDict_SetItemString(d,"LANGUAGE_AFRIKAANS", SWIG_From_int((int)(wxLANGUAGE_AFRIKAANS)));
22382 }
22383 {
22384 PyDict_SetItemString(d,"LANGUAGE_ALBANIAN", SWIG_From_int((int)(wxLANGUAGE_ALBANIAN)));
22385 }
22386 {
22387 PyDict_SetItemString(d,"LANGUAGE_AMHARIC", SWIG_From_int((int)(wxLANGUAGE_AMHARIC)));
22388 }
22389 {
22390 PyDict_SetItemString(d,"LANGUAGE_ARABIC", SWIG_From_int((int)(wxLANGUAGE_ARABIC)));
22391 }
22392 {
22393 PyDict_SetItemString(d,"LANGUAGE_ARABIC_ALGERIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_ALGERIA)));
22394 }
22395 {
22396 PyDict_SetItemString(d,"LANGUAGE_ARABIC_BAHRAIN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_BAHRAIN)));
22397 }
22398 {
22399 PyDict_SetItemString(d,"LANGUAGE_ARABIC_EGYPT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_EGYPT)));
22400 }
22401 {
22402 PyDict_SetItemString(d,"LANGUAGE_ARABIC_IRAQ", SWIG_From_int((int)(wxLANGUAGE_ARABIC_IRAQ)));
22403 }
22404 {
22405 PyDict_SetItemString(d,"LANGUAGE_ARABIC_JORDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_JORDAN)));
22406 }
22407 {
22408 PyDict_SetItemString(d,"LANGUAGE_ARABIC_KUWAIT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_KUWAIT)));
22409 }
22410 {
22411 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LEBANON", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LEBANON)));
22412 }
22413 {
22414 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LIBYA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LIBYA)));
22415 }
22416 {
22417 PyDict_SetItemString(d,"LANGUAGE_ARABIC_MOROCCO", SWIG_From_int((int)(wxLANGUAGE_ARABIC_MOROCCO)));
22418 }
22419 {
22420 PyDict_SetItemString(d,"LANGUAGE_ARABIC_OMAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_OMAN)));
22421 }
22422 {
22423 PyDict_SetItemString(d,"LANGUAGE_ARABIC_QATAR", SWIG_From_int((int)(wxLANGUAGE_ARABIC_QATAR)));
22424 }
22425 {
22426 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SAUDI_ARABIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SAUDI_ARABIA)));
22427 }
22428 {
22429 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SUDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SUDAN)));
22430 }
22431 {
22432 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SYRIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SYRIA)));
22433 }
22434 {
22435 PyDict_SetItemString(d,"LANGUAGE_ARABIC_TUNISIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_TUNISIA)));
22436 }
22437 {
22438 PyDict_SetItemString(d,"LANGUAGE_ARABIC_UAE", SWIG_From_int((int)(wxLANGUAGE_ARABIC_UAE)));
22439 }
22440 {
22441 PyDict_SetItemString(d,"LANGUAGE_ARABIC_YEMEN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_YEMEN)));
22442 }
22443 {
22444 PyDict_SetItemString(d,"LANGUAGE_ARMENIAN", SWIG_From_int((int)(wxLANGUAGE_ARMENIAN)));
22445 }
22446 {
22447 PyDict_SetItemString(d,"LANGUAGE_ASSAMESE", SWIG_From_int((int)(wxLANGUAGE_ASSAMESE)));
22448 }
22449 {
22450 PyDict_SetItemString(d,"LANGUAGE_AYMARA", SWIG_From_int((int)(wxLANGUAGE_AYMARA)));
22451 }
22452 {
22453 PyDict_SetItemString(d,"LANGUAGE_AZERI", SWIG_From_int((int)(wxLANGUAGE_AZERI)));
22454 }
22455 {
22456 PyDict_SetItemString(d,"LANGUAGE_AZERI_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_AZERI_CYRILLIC)));
22457 }
22458 {
22459 PyDict_SetItemString(d,"LANGUAGE_AZERI_LATIN", SWIG_From_int((int)(wxLANGUAGE_AZERI_LATIN)));
22460 }
22461 {
22462 PyDict_SetItemString(d,"LANGUAGE_BASHKIR", SWIG_From_int((int)(wxLANGUAGE_BASHKIR)));
22463 }
22464 {
22465 PyDict_SetItemString(d,"LANGUAGE_BASQUE", SWIG_From_int((int)(wxLANGUAGE_BASQUE)));
22466 }
22467 {
22468 PyDict_SetItemString(d,"LANGUAGE_BELARUSIAN", SWIG_From_int((int)(wxLANGUAGE_BELARUSIAN)));
22469 }
22470 {
22471 PyDict_SetItemString(d,"LANGUAGE_BENGALI", SWIG_From_int((int)(wxLANGUAGE_BENGALI)));
22472 }
22473 {
22474 PyDict_SetItemString(d,"LANGUAGE_BHUTANI", SWIG_From_int((int)(wxLANGUAGE_BHUTANI)));
22475 }
22476 {
22477 PyDict_SetItemString(d,"LANGUAGE_BIHARI", SWIG_From_int((int)(wxLANGUAGE_BIHARI)));
22478 }
22479 {
22480 PyDict_SetItemString(d,"LANGUAGE_BISLAMA", SWIG_From_int((int)(wxLANGUAGE_BISLAMA)));
22481 }
22482 {
22483 PyDict_SetItemString(d,"LANGUAGE_BRETON", SWIG_From_int((int)(wxLANGUAGE_BRETON)));
22484 }
22485 {
22486 PyDict_SetItemString(d,"LANGUAGE_BULGARIAN", SWIG_From_int((int)(wxLANGUAGE_BULGARIAN)));
22487 }
22488 {
22489 PyDict_SetItemString(d,"LANGUAGE_BURMESE", SWIG_From_int((int)(wxLANGUAGE_BURMESE)));
22490 }
22491 {
22492 PyDict_SetItemString(d,"LANGUAGE_CAMBODIAN", SWIG_From_int((int)(wxLANGUAGE_CAMBODIAN)));
22493 }
22494 {
22495 PyDict_SetItemString(d,"LANGUAGE_CATALAN", SWIG_From_int((int)(wxLANGUAGE_CATALAN)));
22496 }
22497 {
22498 PyDict_SetItemString(d,"LANGUAGE_CHINESE", SWIG_From_int((int)(wxLANGUAGE_CHINESE)));
22499 }
22500 {
22501 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SIMPLIFIED", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SIMPLIFIED)));
22502 }
22503 {
22504 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TRADITIONAL", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TRADITIONAL)));
22505 }
22506 {
22507 PyDict_SetItemString(d,"LANGUAGE_CHINESE_HONGKONG", SWIG_From_int((int)(wxLANGUAGE_CHINESE_HONGKONG)));
22508 }
22509 {
22510 PyDict_SetItemString(d,"LANGUAGE_CHINESE_MACAU", SWIG_From_int((int)(wxLANGUAGE_CHINESE_MACAU)));
22511 }
22512 {
22513 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SINGAPORE", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SINGAPORE)));
22514 }
22515 {
22516 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TAIWAN", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TAIWAN)));
22517 }
22518 {
22519 PyDict_SetItemString(d,"LANGUAGE_CORSICAN", SWIG_From_int((int)(wxLANGUAGE_CORSICAN)));
22520 }
22521 {
22522 PyDict_SetItemString(d,"LANGUAGE_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_CROATIAN)));
22523 }
22524 {
22525 PyDict_SetItemString(d,"LANGUAGE_CZECH", SWIG_From_int((int)(wxLANGUAGE_CZECH)));
22526 }
22527 {
22528 PyDict_SetItemString(d,"LANGUAGE_DANISH", SWIG_From_int((int)(wxLANGUAGE_DANISH)));
22529 }
22530 {
22531 PyDict_SetItemString(d,"LANGUAGE_DUTCH", SWIG_From_int((int)(wxLANGUAGE_DUTCH)));
22532 }
22533 {
22534 PyDict_SetItemString(d,"LANGUAGE_DUTCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_DUTCH_BELGIAN)));
22535 }
22536 {
22537 PyDict_SetItemString(d,"LANGUAGE_ENGLISH", SWIG_From_int((int)(wxLANGUAGE_ENGLISH)));
22538 }
22539 {
22540 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_UK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_UK)));
22541 }
22542 {
22543 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_US", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_US)));
22544 }
22545 {
22546 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_AUSTRALIA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_AUSTRALIA)));
22547 }
22548 {
22549 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BELIZE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BELIZE)));
22550 }
22551 {
22552 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BOTSWANA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BOTSWANA)));
22553 }
22554 {
22555 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CANADA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CANADA)));
22556 }
22557 {
22558 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CARIBBEAN", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CARIBBEAN)));
22559 }
22560 {
22561 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_DENMARK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_DENMARK)));
22562 }
22563 {
22564 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_EIRE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_EIRE)));
22565 }
22566 {
22567 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_JAMAICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_JAMAICA)));
22568 }
22569 {
22570 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_NEW_ZEALAND", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_NEW_ZEALAND)));
22571 }
22572 {
22573 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_PHILIPPINES", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_PHILIPPINES)));
22574 }
22575 {
22576 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_SOUTH_AFRICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_SOUTH_AFRICA)));
22577 }
22578 {
22579 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_TRINIDAD", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_TRINIDAD)));
22580 }
22581 {
22582 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_ZIMBABWE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_ZIMBABWE)));
22583 }
22584 {
22585 PyDict_SetItemString(d,"LANGUAGE_ESPERANTO", SWIG_From_int((int)(wxLANGUAGE_ESPERANTO)));
22586 }
22587 {
22588 PyDict_SetItemString(d,"LANGUAGE_ESTONIAN", SWIG_From_int((int)(wxLANGUAGE_ESTONIAN)));
22589 }
22590 {
22591 PyDict_SetItemString(d,"LANGUAGE_FAEROESE", SWIG_From_int((int)(wxLANGUAGE_FAEROESE)));
22592 }
22593 {
22594 PyDict_SetItemString(d,"LANGUAGE_FARSI", SWIG_From_int((int)(wxLANGUAGE_FARSI)));
22595 }
22596 {
22597 PyDict_SetItemString(d,"LANGUAGE_FIJI", SWIG_From_int((int)(wxLANGUAGE_FIJI)));
22598 }
22599 {
22600 PyDict_SetItemString(d,"LANGUAGE_FINNISH", SWIG_From_int((int)(wxLANGUAGE_FINNISH)));
22601 }
22602 {
22603 PyDict_SetItemString(d,"LANGUAGE_FRENCH", SWIG_From_int((int)(wxLANGUAGE_FRENCH)));
22604 }
22605 {
22606 PyDict_SetItemString(d,"LANGUAGE_FRENCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_BELGIAN)));
22607 }
22608 {
22609 PyDict_SetItemString(d,"LANGUAGE_FRENCH_CANADIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_CANADIAN)));
22610 }
22611 {
22612 PyDict_SetItemString(d,"LANGUAGE_FRENCH_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_FRENCH_LUXEMBOURG)));
22613 }
22614 {
22615 PyDict_SetItemString(d,"LANGUAGE_FRENCH_MONACO", SWIG_From_int((int)(wxLANGUAGE_FRENCH_MONACO)));
22616 }
22617 {
22618 PyDict_SetItemString(d,"LANGUAGE_FRENCH_SWISS", SWIG_From_int((int)(wxLANGUAGE_FRENCH_SWISS)));
22619 }
22620 {
22621 PyDict_SetItemString(d,"LANGUAGE_FRISIAN", SWIG_From_int((int)(wxLANGUAGE_FRISIAN)));
22622 }
22623 {
22624 PyDict_SetItemString(d,"LANGUAGE_GALICIAN", SWIG_From_int((int)(wxLANGUAGE_GALICIAN)));
22625 }
22626 {
22627 PyDict_SetItemString(d,"LANGUAGE_GEORGIAN", SWIG_From_int((int)(wxLANGUAGE_GEORGIAN)));
22628 }
22629 {
22630 PyDict_SetItemString(d,"LANGUAGE_GERMAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN)));
22631 }
22632 {
22633 PyDict_SetItemString(d,"LANGUAGE_GERMAN_AUSTRIAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_AUSTRIAN)));
22634 }
22635 {
22636 PyDict_SetItemString(d,"LANGUAGE_GERMAN_BELGIUM", SWIG_From_int((int)(wxLANGUAGE_GERMAN_BELGIUM)));
22637 }
22638 {
22639 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LIECHTENSTEIN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LIECHTENSTEIN)));
22640 }
22641 {
22642 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LUXEMBOURG)));
22643 }
22644 {
22645 PyDict_SetItemString(d,"LANGUAGE_GERMAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_GERMAN_SWISS)));
22646 }
22647 {
22648 PyDict_SetItemString(d,"LANGUAGE_GREEK", SWIG_From_int((int)(wxLANGUAGE_GREEK)));
22649 }
22650 {
22651 PyDict_SetItemString(d,"LANGUAGE_GREENLANDIC", SWIG_From_int((int)(wxLANGUAGE_GREENLANDIC)));
22652 }
22653 {
22654 PyDict_SetItemString(d,"LANGUAGE_GUARANI", SWIG_From_int((int)(wxLANGUAGE_GUARANI)));
22655 }
22656 {
22657 PyDict_SetItemString(d,"LANGUAGE_GUJARATI", SWIG_From_int((int)(wxLANGUAGE_GUJARATI)));
22658 }
22659 {
22660 PyDict_SetItemString(d,"LANGUAGE_HAUSA", SWIG_From_int((int)(wxLANGUAGE_HAUSA)));
22661 }
22662 {
22663 PyDict_SetItemString(d,"LANGUAGE_HEBREW", SWIG_From_int((int)(wxLANGUAGE_HEBREW)));
22664 }
22665 {
22666 PyDict_SetItemString(d,"LANGUAGE_HINDI", SWIG_From_int((int)(wxLANGUAGE_HINDI)));
22667 }
22668 {
22669 PyDict_SetItemString(d,"LANGUAGE_HUNGARIAN", SWIG_From_int((int)(wxLANGUAGE_HUNGARIAN)));
22670 }
22671 {
22672 PyDict_SetItemString(d,"LANGUAGE_ICELANDIC", SWIG_From_int((int)(wxLANGUAGE_ICELANDIC)));
22673 }
22674 {
22675 PyDict_SetItemString(d,"LANGUAGE_INDONESIAN", SWIG_From_int((int)(wxLANGUAGE_INDONESIAN)));
22676 }
22677 {
22678 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUA", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUA)));
22679 }
22680 {
22681 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUE", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUE)));
22682 }
22683 {
22684 PyDict_SetItemString(d,"LANGUAGE_INUKTITUT", SWIG_From_int((int)(wxLANGUAGE_INUKTITUT)));
22685 }
22686 {
22687 PyDict_SetItemString(d,"LANGUAGE_INUPIAK", SWIG_From_int((int)(wxLANGUAGE_INUPIAK)));
22688 }
22689 {
22690 PyDict_SetItemString(d,"LANGUAGE_IRISH", SWIG_From_int((int)(wxLANGUAGE_IRISH)));
22691 }
22692 {
22693 PyDict_SetItemString(d,"LANGUAGE_ITALIAN", SWIG_From_int((int)(wxLANGUAGE_ITALIAN)));
22694 }
22695 {
22696 PyDict_SetItemString(d,"LANGUAGE_ITALIAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_ITALIAN_SWISS)));
22697 }
22698 {
22699 PyDict_SetItemString(d,"LANGUAGE_JAPANESE", SWIG_From_int((int)(wxLANGUAGE_JAPANESE)));
22700 }
22701 {
22702 PyDict_SetItemString(d,"LANGUAGE_JAVANESE", SWIG_From_int((int)(wxLANGUAGE_JAVANESE)));
22703 }
22704 {
22705 PyDict_SetItemString(d,"LANGUAGE_KANNADA", SWIG_From_int((int)(wxLANGUAGE_KANNADA)));
22706 }
22707 {
22708 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI)));
22709 }
22710 {
22711 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI_INDIA", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI_INDIA)));
22712 }
22713 {
22714 PyDict_SetItemString(d,"LANGUAGE_KAZAKH", SWIG_From_int((int)(wxLANGUAGE_KAZAKH)));
22715 }
22716 {
22717 PyDict_SetItemString(d,"LANGUAGE_KERNEWEK", SWIG_From_int((int)(wxLANGUAGE_KERNEWEK)));
22718 }
22719 {
22720 PyDict_SetItemString(d,"LANGUAGE_KINYARWANDA", SWIG_From_int((int)(wxLANGUAGE_KINYARWANDA)));
22721 }
22722 {
22723 PyDict_SetItemString(d,"LANGUAGE_KIRGHIZ", SWIG_From_int((int)(wxLANGUAGE_KIRGHIZ)));
22724 }
22725 {
22726 PyDict_SetItemString(d,"LANGUAGE_KIRUNDI", SWIG_From_int((int)(wxLANGUAGE_KIRUNDI)));
22727 }
22728 {
22729 PyDict_SetItemString(d,"LANGUAGE_KONKANI", SWIG_From_int((int)(wxLANGUAGE_KONKANI)));
22730 }
22731 {
22732 PyDict_SetItemString(d,"LANGUAGE_KOREAN", SWIG_From_int((int)(wxLANGUAGE_KOREAN)));
22733 }
22734 {
22735 PyDict_SetItemString(d,"LANGUAGE_KURDISH", SWIG_From_int((int)(wxLANGUAGE_KURDISH)));
22736 }
22737 {
22738 PyDict_SetItemString(d,"LANGUAGE_LAOTHIAN", SWIG_From_int((int)(wxLANGUAGE_LAOTHIAN)));
22739 }
22740 {
22741 PyDict_SetItemString(d,"LANGUAGE_LATIN", SWIG_From_int((int)(wxLANGUAGE_LATIN)));
22742 }
22743 {
22744 PyDict_SetItemString(d,"LANGUAGE_LATVIAN", SWIG_From_int((int)(wxLANGUAGE_LATVIAN)));
22745 }
22746 {
22747 PyDict_SetItemString(d,"LANGUAGE_LINGALA", SWIG_From_int((int)(wxLANGUAGE_LINGALA)));
22748 }
22749 {
22750 PyDict_SetItemString(d,"LANGUAGE_LITHUANIAN", SWIG_From_int((int)(wxLANGUAGE_LITHUANIAN)));
22751 }
22752 {
22753 PyDict_SetItemString(d,"LANGUAGE_MACEDONIAN", SWIG_From_int((int)(wxLANGUAGE_MACEDONIAN)));
22754 }
22755 {
22756 PyDict_SetItemString(d,"LANGUAGE_MALAGASY", SWIG_From_int((int)(wxLANGUAGE_MALAGASY)));
22757 }
22758 {
22759 PyDict_SetItemString(d,"LANGUAGE_MALAY", SWIG_From_int((int)(wxLANGUAGE_MALAY)));
22760 }
22761 {
22762 PyDict_SetItemString(d,"LANGUAGE_MALAYALAM", SWIG_From_int((int)(wxLANGUAGE_MALAYALAM)));
22763 }
22764 {
22765 PyDict_SetItemString(d,"LANGUAGE_MALAY_BRUNEI_DARUSSALAM", SWIG_From_int((int)(wxLANGUAGE_MALAY_BRUNEI_DARUSSALAM)));
22766 }
22767 {
22768 PyDict_SetItemString(d,"LANGUAGE_MALAY_MALAYSIA", SWIG_From_int((int)(wxLANGUAGE_MALAY_MALAYSIA)));
22769 }
22770 {
22771 PyDict_SetItemString(d,"LANGUAGE_MALTESE", SWIG_From_int((int)(wxLANGUAGE_MALTESE)));
22772 }
22773 {
22774 PyDict_SetItemString(d,"LANGUAGE_MANIPURI", SWIG_From_int((int)(wxLANGUAGE_MANIPURI)));
22775 }
22776 {
22777 PyDict_SetItemString(d,"LANGUAGE_MAORI", SWIG_From_int((int)(wxLANGUAGE_MAORI)));
22778 }
22779 {
22780 PyDict_SetItemString(d,"LANGUAGE_MARATHI", SWIG_From_int((int)(wxLANGUAGE_MARATHI)));
22781 }
22782 {
22783 PyDict_SetItemString(d,"LANGUAGE_MOLDAVIAN", SWIG_From_int((int)(wxLANGUAGE_MOLDAVIAN)));
22784 }
22785 {
22786 PyDict_SetItemString(d,"LANGUAGE_MONGOLIAN", SWIG_From_int((int)(wxLANGUAGE_MONGOLIAN)));
22787 }
22788 {
22789 PyDict_SetItemString(d,"LANGUAGE_NAURU", SWIG_From_int((int)(wxLANGUAGE_NAURU)));
22790 }
22791 {
22792 PyDict_SetItemString(d,"LANGUAGE_NEPALI", SWIG_From_int((int)(wxLANGUAGE_NEPALI)));
22793 }
22794 {
22795 PyDict_SetItemString(d,"LANGUAGE_NEPALI_INDIA", SWIG_From_int((int)(wxLANGUAGE_NEPALI_INDIA)));
22796 }
22797 {
22798 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_BOKMAL", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_BOKMAL)));
22799 }
22800 {
22801 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_NYNORSK", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_NYNORSK)));
22802 }
22803 {
22804 PyDict_SetItemString(d,"LANGUAGE_OCCITAN", SWIG_From_int((int)(wxLANGUAGE_OCCITAN)));
22805 }
22806 {
22807 PyDict_SetItemString(d,"LANGUAGE_ORIYA", SWIG_From_int((int)(wxLANGUAGE_ORIYA)));
22808 }
22809 {
22810 PyDict_SetItemString(d,"LANGUAGE_OROMO", SWIG_From_int((int)(wxLANGUAGE_OROMO)));
22811 }
22812 {
22813 PyDict_SetItemString(d,"LANGUAGE_PASHTO", SWIG_From_int((int)(wxLANGUAGE_PASHTO)));
22814 }
22815 {
22816 PyDict_SetItemString(d,"LANGUAGE_POLISH", SWIG_From_int((int)(wxLANGUAGE_POLISH)));
22817 }
22818 {
22819 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE)));
22820 }
22821 {
22822 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE_BRAZILIAN", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE_BRAZILIAN)));
22823 }
22824 {
22825 PyDict_SetItemString(d,"LANGUAGE_PUNJABI", SWIG_From_int((int)(wxLANGUAGE_PUNJABI)));
22826 }
22827 {
22828 PyDict_SetItemString(d,"LANGUAGE_QUECHUA", SWIG_From_int((int)(wxLANGUAGE_QUECHUA)));
22829 }
22830 {
22831 PyDict_SetItemString(d,"LANGUAGE_RHAETO_ROMANCE", SWIG_From_int((int)(wxLANGUAGE_RHAETO_ROMANCE)));
22832 }
22833 {
22834 PyDict_SetItemString(d,"LANGUAGE_ROMANIAN", SWIG_From_int((int)(wxLANGUAGE_ROMANIAN)));
22835 }
22836 {
22837 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN)));
22838 }
22839 {
22840 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN_UKRAINE", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN_UKRAINE)));
22841 }
22842 {
22843 PyDict_SetItemString(d,"LANGUAGE_SAMOAN", SWIG_From_int((int)(wxLANGUAGE_SAMOAN)));
22844 }
22845 {
22846 PyDict_SetItemString(d,"LANGUAGE_SANGHO", SWIG_From_int((int)(wxLANGUAGE_SANGHO)));
22847 }
22848 {
22849 PyDict_SetItemString(d,"LANGUAGE_SANSKRIT", SWIG_From_int((int)(wxLANGUAGE_SANSKRIT)));
22850 }
22851 {
22852 PyDict_SetItemString(d,"LANGUAGE_SCOTS_GAELIC", SWIG_From_int((int)(wxLANGUAGE_SCOTS_GAELIC)));
22853 }
22854 {
22855 PyDict_SetItemString(d,"LANGUAGE_SERBIAN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN)));
22856 }
22857 {
22858 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_CYRILLIC)));
22859 }
22860 {
22861 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_LATIN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_LATIN)));
22862 }
22863 {
22864 PyDict_SetItemString(d,"LANGUAGE_SERBO_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_SERBO_CROATIAN)));
22865 }
22866 {
22867 PyDict_SetItemString(d,"LANGUAGE_SESOTHO", SWIG_From_int((int)(wxLANGUAGE_SESOTHO)));
22868 }
22869 {
22870 PyDict_SetItemString(d,"LANGUAGE_SETSWANA", SWIG_From_int((int)(wxLANGUAGE_SETSWANA)));
22871 }
22872 {
22873 PyDict_SetItemString(d,"LANGUAGE_SHONA", SWIG_From_int((int)(wxLANGUAGE_SHONA)));
22874 }
22875 {
22876 PyDict_SetItemString(d,"LANGUAGE_SINDHI", SWIG_From_int((int)(wxLANGUAGE_SINDHI)));
22877 }
22878 {
22879 PyDict_SetItemString(d,"LANGUAGE_SINHALESE", SWIG_From_int((int)(wxLANGUAGE_SINHALESE)));
22880 }
22881 {
22882 PyDict_SetItemString(d,"LANGUAGE_SISWATI", SWIG_From_int((int)(wxLANGUAGE_SISWATI)));
22883 }
22884 {
22885 PyDict_SetItemString(d,"LANGUAGE_SLOVAK", SWIG_From_int((int)(wxLANGUAGE_SLOVAK)));
22886 }
22887 {
22888 PyDict_SetItemString(d,"LANGUAGE_SLOVENIAN", SWIG_From_int((int)(wxLANGUAGE_SLOVENIAN)));
22889 }
22890 {
22891 PyDict_SetItemString(d,"LANGUAGE_SOMALI", SWIG_From_int((int)(wxLANGUAGE_SOMALI)));
22892 }
22893 {
22894 PyDict_SetItemString(d,"LANGUAGE_SPANISH", SWIG_From_int((int)(wxLANGUAGE_SPANISH)));
22895 }
22896 {
22897 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ARGENTINA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ARGENTINA)));
22898 }
22899 {
22900 PyDict_SetItemString(d,"LANGUAGE_SPANISH_BOLIVIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_BOLIVIA)));
22901 }
22902 {
22903 PyDict_SetItemString(d,"LANGUAGE_SPANISH_CHILE", SWIG_From_int((int)(wxLANGUAGE_SPANISH_CHILE)));
22904 }
22905 {
22906 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COLOMBIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COLOMBIA)));
22907 }
22908 {
22909 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COSTA_RICA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COSTA_RICA)));
22910 }
22911 {
22912 PyDict_SetItemString(d,"LANGUAGE_SPANISH_DOMINICAN_REPUBLIC", SWIG_From_int((int)(wxLANGUAGE_SPANISH_DOMINICAN_REPUBLIC)));
22913 }
22914 {
22915 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ECUADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ECUADOR)));
22916 }
22917 {
22918 PyDict_SetItemString(d,"LANGUAGE_SPANISH_EL_SALVADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_EL_SALVADOR)));
22919 }
22920 {
22921 PyDict_SetItemString(d,"LANGUAGE_SPANISH_GUATEMALA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_GUATEMALA)));
22922 }
22923 {
22924 PyDict_SetItemString(d,"LANGUAGE_SPANISH_HONDURAS", SWIG_From_int((int)(wxLANGUAGE_SPANISH_HONDURAS)));
22925 }
22926 {
22927 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MEXICAN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MEXICAN)));
22928 }
22929 {
22930 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MODERN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MODERN)));
22931 }
22932 {
22933 PyDict_SetItemString(d,"LANGUAGE_SPANISH_NICARAGUA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_NICARAGUA)));
22934 }
22935 {
22936 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PANAMA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PANAMA)));
22937 }
22938 {
22939 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PARAGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PARAGUAY)));
22940 }
22941 {
22942 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PERU", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PERU)));
22943 }
22944 {
22945 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PUERTO_RICO", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PUERTO_RICO)));
22946 }
22947 {
22948 PyDict_SetItemString(d,"LANGUAGE_SPANISH_URUGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_URUGUAY)));
22949 }
22950 {
22951 PyDict_SetItemString(d,"LANGUAGE_SPANISH_US", SWIG_From_int((int)(wxLANGUAGE_SPANISH_US)));
22952 }
22953 {
22954 PyDict_SetItemString(d,"LANGUAGE_SPANISH_VENEZUELA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_VENEZUELA)));
22955 }
22956 {
22957 PyDict_SetItemString(d,"LANGUAGE_SUNDANESE", SWIG_From_int((int)(wxLANGUAGE_SUNDANESE)));
22958 }
22959 {
22960 PyDict_SetItemString(d,"LANGUAGE_SWAHILI", SWIG_From_int((int)(wxLANGUAGE_SWAHILI)));
22961 }
22962 {
22963 PyDict_SetItemString(d,"LANGUAGE_SWEDISH", SWIG_From_int((int)(wxLANGUAGE_SWEDISH)));
22964 }
22965 {
22966 PyDict_SetItemString(d,"LANGUAGE_SWEDISH_FINLAND", SWIG_From_int((int)(wxLANGUAGE_SWEDISH_FINLAND)));
22967 }
22968 {
22969 PyDict_SetItemString(d,"LANGUAGE_TAGALOG", SWIG_From_int((int)(wxLANGUAGE_TAGALOG)));
22970 }
22971 {
22972 PyDict_SetItemString(d,"LANGUAGE_TAJIK", SWIG_From_int((int)(wxLANGUAGE_TAJIK)));
22973 }
22974 {
22975 PyDict_SetItemString(d,"LANGUAGE_TAMIL", SWIG_From_int((int)(wxLANGUAGE_TAMIL)));
22976 }
22977 {
22978 PyDict_SetItemString(d,"LANGUAGE_TATAR", SWIG_From_int((int)(wxLANGUAGE_TATAR)));
22979 }
22980 {
22981 PyDict_SetItemString(d,"LANGUAGE_TELUGU", SWIG_From_int((int)(wxLANGUAGE_TELUGU)));
22982 }
22983 {
22984 PyDict_SetItemString(d,"LANGUAGE_THAI", SWIG_From_int((int)(wxLANGUAGE_THAI)));
22985 }
22986 {
22987 PyDict_SetItemString(d,"LANGUAGE_TIBETAN", SWIG_From_int((int)(wxLANGUAGE_TIBETAN)));
22988 }
22989 {
22990 PyDict_SetItemString(d,"LANGUAGE_TIGRINYA", SWIG_From_int((int)(wxLANGUAGE_TIGRINYA)));
22991 }
22992 {
22993 PyDict_SetItemString(d,"LANGUAGE_TONGA", SWIG_From_int((int)(wxLANGUAGE_TONGA)));
22994 }
22995 {
22996 PyDict_SetItemString(d,"LANGUAGE_TSONGA", SWIG_From_int((int)(wxLANGUAGE_TSONGA)));
22997 }
22998 {
22999 PyDict_SetItemString(d,"LANGUAGE_TURKISH", SWIG_From_int((int)(wxLANGUAGE_TURKISH)));
23000 }
23001 {
23002 PyDict_SetItemString(d,"LANGUAGE_TURKMEN", SWIG_From_int((int)(wxLANGUAGE_TURKMEN)));
23003 }
23004 {
23005 PyDict_SetItemString(d,"LANGUAGE_TWI", SWIG_From_int((int)(wxLANGUAGE_TWI)));
23006 }
23007 {
23008 PyDict_SetItemString(d,"LANGUAGE_UIGHUR", SWIG_From_int((int)(wxLANGUAGE_UIGHUR)));
23009 }
23010 {
23011 PyDict_SetItemString(d,"LANGUAGE_UKRAINIAN", SWIG_From_int((int)(wxLANGUAGE_UKRAINIAN)));
23012 }
23013 {
23014 PyDict_SetItemString(d,"LANGUAGE_URDU", SWIG_From_int((int)(wxLANGUAGE_URDU)));
23015 }
23016 {
23017 PyDict_SetItemString(d,"LANGUAGE_URDU_INDIA", SWIG_From_int((int)(wxLANGUAGE_URDU_INDIA)));
23018 }
23019 {
23020 PyDict_SetItemString(d,"LANGUAGE_URDU_PAKISTAN", SWIG_From_int((int)(wxLANGUAGE_URDU_PAKISTAN)));
23021 }
23022 {
23023 PyDict_SetItemString(d,"LANGUAGE_UZBEK", SWIG_From_int((int)(wxLANGUAGE_UZBEK)));
23024 }
23025 {
23026 PyDict_SetItemString(d,"LANGUAGE_UZBEK_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_UZBEK_CYRILLIC)));
23027 }
23028 {
23029 PyDict_SetItemString(d,"LANGUAGE_UZBEK_LATIN", SWIG_From_int((int)(wxLANGUAGE_UZBEK_LATIN)));
23030 }
23031 {
23032 PyDict_SetItemString(d,"LANGUAGE_VIETNAMESE", SWIG_From_int((int)(wxLANGUAGE_VIETNAMESE)));
23033 }
23034 {
23035 PyDict_SetItemString(d,"LANGUAGE_VOLAPUK", SWIG_From_int((int)(wxLANGUAGE_VOLAPUK)));
23036 }
23037 {
23038 PyDict_SetItemString(d,"LANGUAGE_WELSH", SWIG_From_int((int)(wxLANGUAGE_WELSH)));
23039 }
23040 {
23041 PyDict_SetItemString(d,"LANGUAGE_WOLOF", SWIG_From_int((int)(wxLANGUAGE_WOLOF)));
23042 }
23043 {
23044 PyDict_SetItemString(d,"LANGUAGE_XHOSA", SWIG_From_int((int)(wxLANGUAGE_XHOSA)));
23045 }
23046 {
23047 PyDict_SetItemString(d,"LANGUAGE_YIDDISH", SWIG_From_int((int)(wxLANGUAGE_YIDDISH)));
23048 }
23049 {
23050 PyDict_SetItemString(d,"LANGUAGE_YORUBA", SWIG_From_int((int)(wxLANGUAGE_YORUBA)));
23051 }
23052 {
23053 PyDict_SetItemString(d,"LANGUAGE_ZHUANG", SWIG_From_int((int)(wxLANGUAGE_ZHUANG)));
23054 }
23055 {
23056 PyDict_SetItemString(d,"LANGUAGE_ZULU", SWIG_From_int((int)(wxLANGUAGE_ZULU)));
23057 }
23058 {
23059 PyDict_SetItemString(d,"LANGUAGE_USER_DEFINED", SWIG_From_int((int)(wxLANGUAGE_USER_DEFINED)));
23060 }
23061 {
23062 PyDict_SetItemString(d,"LOCALE_CAT_NUMBER", SWIG_From_int((int)(wxLOCALE_CAT_NUMBER)));
23063 }
23064 {
23065 PyDict_SetItemString(d,"LOCALE_CAT_DATE", SWIG_From_int((int)(wxLOCALE_CAT_DATE)));
23066 }
23067 {
23068 PyDict_SetItemString(d,"LOCALE_CAT_MONEY", SWIG_From_int((int)(wxLOCALE_CAT_MONEY)));
23069 }
23070 {
23071 PyDict_SetItemString(d,"LOCALE_CAT_MAX", SWIG_From_int((int)(wxLOCALE_CAT_MAX)));
23072 }
23073 {
23074 PyDict_SetItemString(d,"LOCALE_THOUSANDS_SEP", SWIG_From_int((int)(wxLOCALE_THOUSANDS_SEP)));
23075 }
23076 {
23077 PyDict_SetItemString(d,"LOCALE_DECIMAL_POINT", SWIG_From_int((int)(wxLOCALE_DECIMAL_POINT)));
23078 }
23079 {
23080 PyDict_SetItemString(d,"LOCALE_LOAD_DEFAULT", SWIG_From_int((int)(wxLOCALE_LOAD_DEFAULT)));
23081 }
23082 {
23083 PyDict_SetItemString(d,"LOCALE_CONV_ENCODING", SWIG_From_int((int)(wxLOCALE_CONV_ENCODING)));
23084 }
23085 {
23086 PyDict_SetItemString(d,"CONVERT_STRICT", SWIG_From_int((int)(wxCONVERT_STRICT)));
23087 }
23088 {
23089 PyDict_SetItemString(d,"CONVERT_SUBSTITUTE", SWIG_From_int((int)(wxCONVERT_SUBSTITUTE)));
23090 }
23091 {
23092 PyDict_SetItemString(d,"PLATFORM_CURRENT", SWIG_From_int((int)(wxPLATFORM_CURRENT)));
23093 }
23094 {
23095 PyDict_SetItemString(d,"PLATFORM_UNIX", SWIG_From_int((int)(wxPLATFORM_UNIX)));
23096 }
23097 {
23098 PyDict_SetItemString(d,"PLATFORM_WINDOWS", SWIG_From_int((int)(wxPLATFORM_WINDOWS)));
23099 }
23100 {
23101 PyDict_SetItemString(d,"PLATFORM_OS2", SWIG_From_int((int)(wxPLATFORM_OS2)));
23102 }
23103 {
23104 PyDict_SetItemString(d,"PLATFORM_MAC", SWIG_From_int((int)(wxPLATFORM_MAC)));
23105 }
23106 {
23107 PyDict_SetItemString(d,"IMAGELIST_DRAW_NORMAL", SWIG_From_int((int)(wxIMAGELIST_DRAW_NORMAL)));
23108 }
23109 {
23110 PyDict_SetItemString(d,"IMAGELIST_DRAW_TRANSPARENT", SWIG_From_int((int)(wxIMAGELIST_DRAW_TRANSPARENT)));
23111 }
23112 {
23113 PyDict_SetItemString(d,"IMAGELIST_DRAW_SELECTED", SWIG_From_int((int)(wxIMAGELIST_DRAW_SELECTED)));
23114 }
23115 {
23116 PyDict_SetItemString(d,"IMAGELIST_DRAW_FOCUSED", SWIG_From_int((int)(wxIMAGELIST_DRAW_FOCUSED)));
23117 }
23118 {
23119 PyDict_SetItemString(d,"IMAGE_LIST_NORMAL", SWIG_From_int((int)(wxIMAGE_LIST_NORMAL)));
23120 }
23121 {
23122 PyDict_SetItemString(d,"IMAGE_LIST_SMALL", SWIG_From_int((int)(wxIMAGE_LIST_SMALL)));
23123 }
23124 {
23125 PyDict_SetItemString(d,"IMAGE_LIST_STATE", SWIG_From_int((int)(wxIMAGE_LIST_STATE)));
23126 }
23127 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
23128 SWIG_addvarlink(SWIG_globals,(char*)"NORMAL_FONT",_wrap_NORMAL_FONT_get, _wrap_NORMAL_FONT_set);
23129 SWIG_addvarlink(SWIG_globals,(char*)"SMALL_FONT",_wrap_SMALL_FONT_get, _wrap_SMALL_FONT_set);
23130 SWIG_addvarlink(SWIG_globals,(char*)"ITALIC_FONT",_wrap_ITALIC_FONT_get, _wrap_ITALIC_FONT_set);
23131 SWIG_addvarlink(SWIG_globals,(char*)"SWISS_FONT",_wrap_SWISS_FONT_get, _wrap_SWISS_FONT_set);
23132 SWIG_addvarlink(SWIG_globals,(char*)"RED_PEN",_wrap_RED_PEN_get, _wrap_RED_PEN_set);
23133 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_PEN",_wrap_CYAN_PEN_get, _wrap_CYAN_PEN_set);
23134 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_PEN",_wrap_GREEN_PEN_get, _wrap_GREEN_PEN_set);
23135 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_PEN",_wrap_BLACK_PEN_get, _wrap_BLACK_PEN_set);
23136 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_PEN",_wrap_WHITE_PEN_get, _wrap_WHITE_PEN_set);
23137 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_PEN",_wrap_TRANSPARENT_PEN_get, _wrap_TRANSPARENT_PEN_set);
23138 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_DASHED_PEN",_wrap_BLACK_DASHED_PEN_get, _wrap_BLACK_DASHED_PEN_set);
23139 SWIG_addvarlink(SWIG_globals,(char*)"GREY_PEN",_wrap_GREY_PEN_get, _wrap_GREY_PEN_set);
23140 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_PEN",_wrap_MEDIUM_GREY_PEN_get, _wrap_MEDIUM_GREY_PEN_set);
23141 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_PEN",_wrap_LIGHT_GREY_PEN_get, _wrap_LIGHT_GREY_PEN_set);
23142 SWIG_addvarlink(SWIG_globals,(char*)"BLUE_BRUSH",_wrap_BLUE_BRUSH_get, _wrap_BLUE_BRUSH_set);
23143 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_BRUSH",_wrap_GREEN_BRUSH_get, _wrap_GREEN_BRUSH_set);
23144 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_BRUSH",_wrap_WHITE_BRUSH_get, _wrap_WHITE_BRUSH_set);
23145 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_BRUSH",_wrap_BLACK_BRUSH_get, _wrap_BLACK_BRUSH_set);
23146 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_BRUSH",_wrap_TRANSPARENT_BRUSH_get, _wrap_TRANSPARENT_BRUSH_set);
23147 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_BRUSH",_wrap_CYAN_BRUSH_get, _wrap_CYAN_BRUSH_set);
23148 SWIG_addvarlink(SWIG_globals,(char*)"RED_BRUSH",_wrap_RED_BRUSH_get, _wrap_RED_BRUSH_set);
23149 SWIG_addvarlink(SWIG_globals,(char*)"GREY_BRUSH",_wrap_GREY_BRUSH_get, _wrap_GREY_BRUSH_set);
23150 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_BRUSH",_wrap_MEDIUM_GREY_BRUSH_get, _wrap_MEDIUM_GREY_BRUSH_set);
23151 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_BRUSH",_wrap_LIGHT_GREY_BRUSH_get, _wrap_LIGHT_GREY_BRUSH_set);
23152 SWIG_addvarlink(SWIG_globals,(char*)"BLACK",_wrap_BLACK_get, _wrap_BLACK_set);
23153 SWIG_addvarlink(SWIG_globals,(char*)"WHITE",_wrap_WHITE_get, _wrap_WHITE_set);
23154 SWIG_addvarlink(SWIG_globals,(char*)"RED",_wrap_RED_get, _wrap_RED_set);
23155 SWIG_addvarlink(SWIG_globals,(char*)"BLUE",_wrap_BLUE_get, _wrap_BLUE_set);
23156 SWIG_addvarlink(SWIG_globals,(char*)"GREEN",_wrap_GREEN_get, _wrap_GREEN_set);
23157 SWIG_addvarlink(SWIG_globals,(char*)"CYAN",_wrap_CYAN_get, _wrap_CYAN_set);
23158 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY",_wrap_LIGHT_GREY_get, _wrap_LIGHT_GREY_set);
23159 SWIG_addvarlink(SWIG_globals,(char*)"STANDARD_CURSOR",_wrap_STANDARD_CURSOR_get, _wrap_STANDARD_CURSOR_set);
23160 SWIG_addvarlink(SWIG_globals,(char*)"HOURGLASS_CURSOR",_wrap_HOURGLASS_CURSOR_get, _wrap_HOURGLASS_CURSOR_set);
23161 SWIG_addvarlink(SWIG_globals,(char*)"CROSS_CURSOR",_wrap_CROSS_CURSOR_get, _wrap_CROSS_CURSOR_set);
23162 SWIG_addvarlink(SWIG_globals,(char*)"NullBitmap",_wrap_NullBitmap_get, _wrap_NullBitmap_set);
23163 SWIG_addvarlink(SWIG_globals,(char*)"NullIcon",_wrap_NullIcon_get, _wrap_NullIcon_set);
23164 SWIG_addvarlink(SWIG_globals,(char*)"NullCursor",_wrap_NullCursor_get, _wrap_NullCursor_set);
23165 SWIG_addvarlink(SWIG_globals,(char*)"NullPen",_wrap_NullPen_get, _wrap_NullPen_set);
23166 SWIG_addvarlink(SWIG_globals,(char*)"NullBrush",_wrap_NullBrush_get, _wrap_NullBrush_set);
23167 SWIG_addvarlink(SWIG_globals,(char*)"NullPalette",_wrap_NullPalette_get, _wrap_NullPalette_set);
23168 SWIG_addvarlink(SWIG_globals,(char*)"NullFont",_wrap_NullFont_get, _wrap_NullFont_set);
23169 SWIG_addvarlink(SWIG_globals,(char*)"NullColour",_wrap_NullColour_get, _wrap_NullColour_set);
23170 SWIG_addvarlink(SWIG_globals,(char*)"TheFontList",_wrap_TheFontList_get, _wrap_TheFontList_set);
23171 SWIG_addvarlink(SWIG_globals,(char*)"ThePenList",_wrap_ThePenList_get, _wrap_ThePenList_set);
23172 SWIG_addvarlink(SWIG_globals,(char*)"TheBrushList",_wrap_TheBrushList_get, _wrap_TheBrushList_set);
23173 SWIG_addvarlink(SWIG_globals,(char*)"TheColourDatabase",_wrap_TheColourDatabase_get, _wrap_TheColourDatabase_set);
23174
23175 // Work around a chicken/egg problem in drawlist.cpp
23176 wxPyDrawList_SetAPIPtr();
23177
23178 }
23179
wxWidgets (Impactor)