]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_gdi_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Note that some deprecated items have been removed
[wxWidgets.git] / wxPython / src / msw / _gdi_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 if (str)
1041 Py_DECREF(str);
1042 return;
1043 }
1044 }
1045 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1046 } else {
1047 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1048 }
1049 }
1050
1051 SWIGRUNTIMEINLINE void
1052 SWIG_Python_NullRef(const char *type)
1053 {
1054 if (type) {
1055 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1056 } else {
1057 PyErr_Format(PyExc_TypeError, "null reference was received");
1058 }
1059 }
1060
1061 SWIGRUNTIME int
1062 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1063 {
1064 if (PyErr_Occurred()) {
1065 PyObject *type = 0;
1066 PyObject *value = 0;
1067 PyObject *traceback = 0;
1068 PyErr_Fetch(&type, &value, &traceback);
1069 if (value) {
1070 PyObject *old_str = PyObject_Str(value);
1071 Py_XINCREF(type);
1072 PyErr_Clear();
1073 if (infront) {
1074 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1075 } else {
1076 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1077 }
1078 Py_DECREF(old_str);
1079 }
1080 return 1;
1081 } else {
1082 return 0;
1083 }
1084 }
1085
1086 SWIGRUNTIME int
1087 SWIG_Python_ArgFail(int argnum)
1088 {
1089 if (PyErr_Occurred()) {
1090 /* add information about failing argument */
1091 char mesg[256];
1092 sprintf(mesg, "argument number %d:", argnum);
1093 return SWIG_Python_AddErrMesg(mesg, 1);
1094 } else {
1095 return 0;
1096 }
1097 }
1098
1099
1100 /* -----------------------------------------------------------------------------
1101 * pointers/data manipulation
1102 * ----------------------------------------------------------------------------- */
1103
1104 /* Convert a pointer value */
1105 SWIGRUNTIME int
1106 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1107 swig_type_info *tc;
1108 const char *c = 0;
1109 static PyObject *SWIG_this = 0;
1110 int newref = 0;
1111 PyObject *pyobj = 0;
1112 void *vptr;
1113
1114 if (!obj) return 0;
1115 if (obj == Py_None) {
1116 *ptr = 0;
1117 return 0;
1118 }
1119
1120 #ifdef SWIG_COBJECT_TYPES
1121 if (!(PySwigObject_Check(obj))) {
1122 if (!SWIG_this)
1123 SWIG_this = PyString_FromString("this");
1124 pyobj = obj;
1125 obj = PyObject_GetAttr(obj,SWIG_this);
1126 newref = 1;
1127 if (!obj) goto type_error;
1128 if (!PySwigObject_Check(obj)) {
1129 Py_DECREF(obj);
1130 goto type_error;
1131 }
1132 }
1133 vptr = PySwigObject_AsVoidPtr(obj);
1134 c = (const char *) PySwigObject_GetDesc(obj);
1135 if (newref) { Py_DECREF(obj); }
1136 goto type_check;
1137 #else
1138 if (!(PyString_Check(obj))) {
1139 if (!SWIG_this)
1140 SWIG_this = PyString_FromString("this");
1141 pyobj = obj;
1142 obj = PyObject_GetAttr(obj,SWIG_this);
1143 newref = 1;
1144 if (!obj) goto type_error;
1145 if (!PyString_Check(obj)) {
1146 Py_DECREF(obj);
1147 goto type_error;
1148 }
1149 }
1150 c = PyString_AS_STRING(obj);
1151 /* Pointer values must start with leading underscore */
1152 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1153 if (newref) { Py_DECREF(obj); }
1154 if (!c) goto type_error;
1155 #endif
1156
1157 type_check:
1158
1159 if (ty) {
1160 tc = SWIG_TypeCheck(c,ty);
1161 if (!tc) goto type_error;
1162 *ptr = SWIG_TypeCast(tc,vptr);
1163 } else {
1164 *ptr = vptr;
1165 }
1166
1167 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1168 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1169 }
1170 return 0;
1171
1172 type_error:
1173 PyErr_Clear();
1174 if (pyobj && !obj) {
1175 obj = pyobj;
1176 if (PyCFunction_Check(obj)) {
1177 /* here we get the method pointer for callbacks */
1178 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1179 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1180 if (c) {
1181 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1182 if (!c) goto type_error;
1183 goto type_check;
1184 }
1185 }
1186 }
1187 if (flags & SWIG_POINTER_EXCEPTION) {
1188 if (ty) {
1189 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1190 } else {
1191 SWIG_Python_TypeError("C/C++ pointer", obj);
1192 }
1193 }
1194 return -1;
1195 }
1196
1197 /* Convert a pointer value, signal an exception on a type mismatch */
1198 SWIGRUNTIME void *
1199 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1200 void *result;
1201 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1202 PyErr_Clear();
1203 if (flags & SWIG_POINTER_EXCEPTION) {
1204 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1205 SWIG_Python_ArgFail(argnum);
1206 }
1207 }
1208 return result;
1209 }
1210
1211 /* Convert a packed value value */
1212 SWIGRUNTIME int
1213 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1214 swig_type_info *tc;
1215 const char *c = 0;
1216
1217 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1218 c = PySwigPacked_UnpackData(obj, ptr, sz);
1219 #else
1220 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1221 c = PyString_AS_STRING(obj);
1222 /* Pointer values must start with leading underscore */
1223 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1224 #endif
1225 if (!c) goto type_error;
1226 if (ty) {
1227 tc = SWIG_TypeCheck(c,ty);
1228 if (!tc) goto type_error;
1229 }
1230 return 0;
1231
1232 type_error:
1233 PyErr_Clear();
1234 if (flags & SWIG_POINTER_EXCEPTION) {
1235 if (ty) {
1236 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1237 } else {
1238 SWIG_Python_TypeError("C/C++ packed data", obj);
1239 }
1240 }
1241 return -1;
1242 }
1243
1244 /* Create a new array object */
1245 SWIGRUNTIME PyObject *
1246 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1247 PyObject *robj = 0;
1248 if (!ptr) {
1249 Py_INCREF(Py_None);
1250 return Py_None;
1251 }
1252 #ifdef SWIG_COBJECT_TYPES
1253 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1254 #else
1255 {
1256 char result[SWIG_BUFFER_SIZE];
1257 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1258 PyString_FromString(result) : 0;
1259 }
1260 #endif
1261 if (!robj || (robj == Py_None)) return robj;
1262 if (type->clientdata) {
1263 PyObject *inst;
1264 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1265 Py_DECREF(robj);
1266 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1267 Py_DECREF(args);
1268 if (inst) {
1269 if (own) {
1270 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1271 }
1272 robj = inst;
1273 }
1274 }
1275 return robj;
1276 }
1277
1278 SWIGRUNTIME PyObject *
1279 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1280 PyObject *robj = 0;
1281 if (!ptr) {
1282 Py_INCREF(Py_None);
1283 return Py_None;
1284 }
1285 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1286 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1287 #else
1288 {
1289 char result[SWIG_BUFFER_SIZE];
1290 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1291 PyString_FromString(result) : 0;
1292 }
1293 #endif
1294 return robj;
1295 }
1296
1297 /* -----------------------------------------------------------------------------*
1298 * Get type list
1299 * -----------------------------------------------------------------------------*/
1300
1301 #ifdef SWIG_LINK_RUNTIME
1302 void *SWIG_ReturnGlobalTypeList(void *);
1303 #endif
1304
1305 SWIGRUNTIME swig_type_info **
1306 SWIG_Python_GetTypeListHandle() {
1307 static void *type_pointer = (void *)0;
1308 /* first check if module already created */
1309 if (!type_pointer) {
1310 #ifdef SWIG_LINK_RUNTIME
1311 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1312 #else
1313 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1314 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1315 if (PyErr_Occurred()) {
1316 PyErr_Clear();
1317 type_pointer = (void *)0;
1318 }
1319 }
1320 #endif
1321 return (swig_type_info **) type_pointer;
1322 }
1323
1324 /*
1325 Search for a swig_type_info structure
1326 */
1327 SWIGRUNTIMEINLINE swig_type_info *
1328 SWIG_Python_GetTypeList() {
1329 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1330 return tlh ? *tlh : (swig_type_info*)0;
1331 }
1332
1333 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1334
1335 #ifdef __cplusplus
1336 }
1337 #endif
1338
1339
1340 /* -------- TYPES TABLE (BEGIN) -------- */
1341
1342 #define SWIGTYPE_p_wxPostScriptDC swig_types[0]
1343 #define SWIGTYPE_p_wxBrush swig_types[1]
1344 #define SWIGTYPE_p_wxColour swig_types[2]
1345 #define SWIGTYPE_p_wxDC swig_types[3]
1346 #define SWIGTYPE_p_wxMirrorDC swig_types[4]
1347 #define SWIGTYPE_p_form_ops_t swig_types[5]
1348 #define SWIGTYPE_p_wxRendererVersion swig_types[6]
1349 #define SWIGTYPE_p_wxDuplexMode swig_types[7]
1350 #define SWIGTYPE_p_wxPyFontEnumerator swig_types[8]
1351 #define SWIGTYPE_p_char swig_types[9]
1352 #define SWIGTYPE_p_wxIconLocation swig_types[10]
1353 #define SWIGTYPE_p_wxImage swig_types[11]
1354 #define SWIGTYPE_p_wxMetaFileDC swig_types[12]
1355 #define SWIGTYPE_p_wxMask swig_types[13]
1356 #define SWIGTYPE_p_wxSize swig_types[14]
1357 #define SWIGTYPE_p_wxFont swig_types[15]
1358 #define SWIGTYPE_p_wxWindow swig_types[16]
1359 #define SWIGTYPE_p_double swig_types[17]
1360 #define SWIGTYPE_p_wxMemoryDC swig_types[18]
1361 #define SWIGTYPE_p_wxFontMapper swig_types[19]
1362 #define SWIGTYPE_p_wxEffects swig_types[20]
1363 #define SWIGTYPE_p_wxNativeEncodingInfo swig_types[21]
1364 #define SWIGTYPE_p_wxPalette swig_types[22]
1365 #define SWIGTYPE_p_wxBitmap swig_types[23]
1366 #define SWIGTYPE_p_wxObject swig_types[24]
1367 #define SWIGTYPE_p_wxRegionIterator swig_types[25]
1368 #define SWIGTYPE_p_wxRect swig_types[26]
1369 #define SWIGTYPE_p_wxPaperSize swig_types[27]
1370 #define SWIGTYPE_p_wxString swig_types[28]
1371 #define SWIGTYPE_unsigned_int swig_types[29]
1372 #define SWIGTYPE_p_unsigned_int swig_types[30]
1373 #define SWIGTYPE_p_wxPrinterDC swig_types[31]
1374 #define SWIGTYPE_p_wxIconBundle swig_types[32]
1375 #define SWIGTYPE_p_wxPoint swig_types[33]
1376 #define SWIGTYPE_p_wxDash swig_types[34]
1377 #define SWIGTYPE_p_wxScreenDC swig_types[35]
1378 #define SWIGTYPE_p_wxCursor swig_types[36]
1379 #define SWIGTYPE_p_wxClientDC swig_types[37]
1380 #define SWIGTYPE_p_wxBufferedDC swig_types[38]
1381 #define SWIGTYPE_p_wxImageList swig_types[39]
1382 #define SWIGTYPE_p_unsigned_char swig_types[40]
1383 #define SWIGTYPE_p_wxGDIObject swig_types[41]
1384 #define SWIGTYPE_p_wxIcon swig_types[42]
1385 #define SWIGTYPE_p_wxLocale swig_types[43]
1386 #define SWIGTYPE_ptrdiff_t swig_types[44]
1387 #define SWIGTYPE_std__ptrdiff_t swig_types[45]
1388 #define SWIGTYPE_p_wxRegion swig_types[46]
1389 #define SWIGTYPE_p_wxConfigBase swig_types[47]
1390 #define SWIGTYPE_p_wxLanguageInfo swig_types[48]
1391 #define SWIGTYPE_p_wxWindowDC swig_types[49]
1392 #define SWIGTYPE_p_wxPrintData swig_types[50]
1393 #define SWIGTYPE_p_wxBrushList swig_types[51]
1394 #define SWIGTYPE_p_wxFontList swig_types[52]
1395 #define SWIGTYPE_p_wxPen swig_types[53]
1396 #define SWIGTYPE_p_wxBufferedPaintDC swig_types[54]
1397 #define SWIGTYPE_p_wxPaintDC swig_types[55]
1398 #define SWIGTYPE_p_wxPenList swig_types[56]
1399 #define SWIGTYPE_p_int swig_types[57]
1400 #define SWIGTYPE_p_wxMetaFile swig_types[58]
1401 #define SWIGTYPE_p_wxRendererNative swig_types[59]
1402 #define SWIGTYPE_p_unsigned_long swig_types[60]
1403 #define SWIGTYPE_p_wxNativeFontInfo swig_types[61]
1404 #define SWIGTYPE_p_wxEncodingConverter swig_types[62]
1405 #define SWIGTYPE_p_wxSplitterRenderParams swig_types[63]
1406 #define SWIGTYPE_p_wxColourDatabase swig_types[64]
1407 static swig_type_info *swig_types[66];
1408
1409 /* -------- TYPES TABLE (END) -------- */
1410
1411
1412 /*-----------------------------------------------
1413 @(target):= _gdi_.so
1414 ------------------------------------------------*/
1415 #define SWIG_init init_gdi_
1416
1417 #define SWIG_name "_gdi_"
1418
1419 #include "wx/wxPython/wxPython.h"
1420 #include "wx/wxPython/pyclasses.h"
1421
1422
1423 static const wxString wxPyEmptyString(wxEmptyString);
1424
1425 #include <limits.h>
1426
1427
1428 SWIGINTERN int
1429 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1430 const char *errmsg)
1431 {
1432 if (value < min_value) {
1433 if (errmsg) {
1434 PyErr_Format(PyExc_OverflowError,
1435 "value %ld is less than '%s' minimum %ld",
1436 value, errmsg, min_value);
1437 }
1438 return 0;
1439 } else if (value > max_value) {
1440 if (errmsg) {
1441 PyErr_Format(PyExc_OverflowError,
1442 "value %ld is greater than '%s' maximum %ld",
1443 value, errmsg, max_value);
1444 }
1445 return 0;
1446 }
1447 return 1;
1448 }
1449
1450
1451 SWIGINTERN int
1452 SWIG_AsVal_long(PyObject* obj, long* val)
1453 {
1454 if (PyNumber_Check(obj)) {
1455 if (val) *val = PyInt_AsLong(obj);
1456 return 1;
1457 }
1458 else {
1459 SWIG_type_error("number", obj);
1460 }
1461 return 0;
1462 }
1463
1464
1465 #if INT_MAX != LONG_MAX
1466 SWIGINTERN int
1467 SWIG_AsVal_int(PyObject *obj, int *val)
1468 {
1469 const char* errmsg = val ? "int" : (char*)0;
1470 long v;
1471 if (SWIG_AsVal_long(obj, &v)) {
1472 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1473 if (val) *val = (int)(v);
1474 return 1;
1475 } else {
1476 return 0;
1477 }
1478 } else {
1479 PyErr_Clear();
1480 }
1481 if (val) {
1482 SWIG_type_error(errmsg, obj);
1483 }
1484 return 0;
1485 }
1486 #else
1487 SWIGINTERNSHORT int
1488 SWIG_AsVal_int(PyObject *obj, int *val)
1489 {
1490 return SWIG_AsVal_long(obj,(long*)val);
1491 }
1492 #endif
1493
1494
1495 SWIGINTERN int
1496 SWIG_AsVal_bool(PyObject *obj, bool *val)
1497 {
1498 if (obj == Py_True) {
1499 if (val) *val = true;
1500 return 1;
1501 }
1502 if (obj == Py_False) {
1503 if (val) *val = false;
1504 return 1;
1505 }
1506 int res = 0;
1507 if (SWIG_AsVal_int(obj, &res)) {
1508 if (val) *val = res ? true : false;
1509 return 1;
1510 } else {
1511 PyErr_Clear();
1512 }
1513 if (val) {
1514 SWIG_type_error("bool", obj);
1515 }
1516 return 0;
1517 }
1518
1519
1520 SWIGINTERNSHORT bool
1521 SWIG_As_bool(PyObject* obj)
1522 {
1523 bool v;
1524 if (!SWIG_AsVal_bool(obj, &v)) {
1525 /*
1526 this is needed to make valgrind/purify happier.
1527 */
1528 memset((void*)&v, 0, sizeof(bool));
1529 }
1530 return v;
1531 }
1532
1533
1534 SWIGINTERNSHORT int
1535 SWIG_Check_bool(PyObject* obj)
1536 {
1537 return SWIG_AsVal_bool(obj, (bool*)0);
1538 }
1539
1540
1541 SWIGINTERN int
1542 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1543 {
1544 long v = 0;
1545 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1546 SWIG_type_error("unsigned number", obj);
1547 }
1548 else if (val)
1549 *val = (unsigned long)v;
1550 return 1;
1551 }
1552
1553
1554 SWIGINTERNSHORT int
1555 SWIG_CheckUnsignedLongInRange(unsigned long value,
1556 unsigned long max_value,
1557 const char *errmsg)
1558 {
1559 if (value > max_value) {
1560 if (errmsg) {
1561 PyErr_Format(PyExc_OverflowError,
1562 "value %lu is greater than '%s' minimum %lu",
1563 value, errmsg, max_value);
1564 }
1565 return 0;
1566 }
1567 return 1;
1568 }
1569
1570
1571 SWIGINTERN int
1572 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
1573 {
1574 const char* errmsg = val ? "unsigned char" : (char*)0;
1575 unsigned long v;
1576 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1577 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
1578 if (val) *val = (unsigned char)(v);
1579 return 1;
1580 } else {
1581 return 0;
1582 }
1583 } else {
1584 PyErr_Clear();
1585 }
1586 if (val) {
1587 SWIG_type_error(errmsg, obj);
1588 }
1589 return 0;
1590 }
1591
1592
1593 SWIGINTERNSHORT unsigned char
1594 SWIG_As_unsigned_SS_char(PyObject* obj)
1595 {
1596 unsigned char v;
1597 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
1598 /*
1599 this is needed to make valgrind/purify happier.
1600 */
1601 memset((void*)&v, 0, sizeof(unsigned char));
1602 }
1603 return v;
1604 }
1605
1606
1607 SWIGINTERNSHORT int
1608 SWIG_Check_unsigned_SS_char(PyObject* obj)
1609 {
1610 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
1611 }
1612
1613
1614 SWIGINTERNSHORT unsigned long
1615 SWIG_As_unsigned_SS_long(PyObject* obj)
1616 {
1617 unsigned long v;
1618 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1619 /*
1620 this is needed to make valgrind/purify happier.
1621 */
1622 memset((void*)&v, 0, sizeof(unsigned long));
1623 }
1624 return v;
1625 }
1626
1627
1628 SWIGINTERNSHORT int
1629 SWIG_Check_unsigned_SS_long(PyObject* obj)
1630 {
1631 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1632 }
1633
1634
1635 /*@C:\\SWIG-1.3.24\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1636 #define SWIG_From_unsigned_SS_char PyInt_FromLong
1637 /*@@*/
1638
1639
1640 /*@C:\\SWIG-1.3.24\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1641 #define SWIG_From_long PyInt_FromLong
1642 /*@@*/
1643
1644 static PyObject *wxColour_Get(wxColour *self){
1645 PyObject* rv = PyTuple_New(3);
1646 int red = -1;
1647 int green = -1;
1648 int blue = -1;
1649 if (self->Ok()) {
1650 red = self->Red();
1651 green = self->Green();
1652 blue = self->Blue();
1653 }
1654 PyTuple_SetItem(rv, 0, PyInt_FromLong(red));
1655 PyTuple_SetItem(rv, 1, PyInt_FromLong(green));
1656 PyTuple_SetItem(rv, 2, PyInt_FromLong(blue));
1657 return rv;
1658 }
1659 static unsigned long wxColour_GetRGB(wxColour *self){
1660 return self->Red() | (self->Green() << 8) | (self->Blue() << 16);
1661 }
1662
1663 SWIGINTERNSHORT PyObject*
1664 SWIG_From_unsigned_SS_long(unsigned long value)
1665 {
1666 return (value > LONG_MAX) ?
1667 PyLong_FromUnsignedLong(value)
1668 : PyInt_FromLong((long)(value));
1669 }
1670
1671
1672 SWIGINTERNSHORT int
1673 SWIG_As_int(PyObject* obj)
1674 {
1675 int v;
1676 if (!SWIG_AsVal_int(obj, &v)) {
1677 /*
1678 this is needed to make valgrind/purify happier.
1679 */
1680 memset((void*)&v, 0, sizeof(int));
1681 }
1682 return v;
1683 }
1684
1685
1686 SWIGINTERNSHORT int
1687 SWIG_Check_int(PyObject* obj)
1688 {
1689 return SWIG_AsVal_int(obj, (int*)0);
1690 }
1691
1692
1693 /*@C:\\SWIG-1.3.24\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1694 #define SWIG_From_int PyInt_FromLong
1695 /*@@*/
1696
1697
1698 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1699 PyObject* o2;
1700 PyObject* o3;
1701
1702 if (!target) {
1703 target = o;
1704 } else if (target == Py_None) {
1705 Py_DECREF(Py_None);
1706 target = o;
1707 } else {
1708 if (!PyTuple_Check(target)) {
1709 o2 = target;
1710 target = PyTuple_New(1);
1711 PyTuple_SetItem(target, 0, o2);
1712 }
1713 o3 = PyTuple_New(1);
1714 PyTuple_SetItem(o3, 0, o);
1715
1716 o2 = target;
1717 target = PySequence_Concat(o2, o3);
1718 Py_DECREF(o2);
1719 Py_DECREF(o3);
1720 }
1721 return target;
1722 }
1723
1724
1725 static PyObject *wxPen_GetDashes(wxPen *self){
1726 wxDash* dashes;
1727 int count = self->GetDashes(&dashes);
1728 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1729 PyObject* retval = PyList_New(0);
1730 for (int x=0; x<count; x++) {
1731 PyObject* pyint = PyInt_FromLong(dashes[x]);
1732 PyList_Append(retval, pyint);
1733 Py_DECREF(pyint);
1734 }
1735 wxPyEndBlockThreads(blocked);
1736 return retval;
1737 }
1738 static void wxPen__SetDashes(wxPen *self,PyObject *_self,PyObject *pyDashes){
1739 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1740 int size = PyList_Size(pyDashes);
1741 wxDash* dashes = (wxDash*)byte_LIST_helper(pyDashes);
1742
1743 // black magic warning! The array of wxDashes needs to exist as
1744 // long as the pen does because wxPen does not copy the array. So
1745 // stick a copy in a Python string object and attach it to _self,
1746 // and then call SetDashes with a pointer to that array. Then
1747 // when the Python pen object is destroyed the array will be
1748 // cleaned up too.
1749 PyObject* strDashes = PyString_FromStringAndSize((char*)dashes, size*sizeof(wxDash));
1750 PyObject_SetAttrString(_self, "_dashes", strDashes);
1751
1752 self->SetDashes(size, (wxDash*)PyString_AS_STRING(strDashes));
1753 delete [] dashes;
1754 Py_DECREF(strDashes);
1755 wxPyEndBlockThreads(blocked);
1756 }
1757 static bool wxPen___eq__(wxPen *self,wxPen const *other){ return other ? (*self == *other) : false; }
1758 static bool wxPen___ne__(wxPen *self,wxPen const *other){ return other ? (*self != *other) : true; }
1759
1760 #include <wx/image.h>
1761
1762 static char** ConvertListOfStrings(PyObject* listOfStrings) {
1763 char** cArray = NULL;
1764 int count;
1765
1766 if (!PyList_Check(listOfStrings)) {
1767 PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
1768 return NULL;
1769 }
1770 count = PyList_Size(listOfStrings);
1771 cArray = new char*[count];
1772
1773 for(int x=0; x<count; x++) {
1774 // TODO: Need some validation and error checking here
1775 cArray[x] = PyString_AsString(PyList_GET_ITEM(listOfStrings, x));
1776 }
1777 return cArray;
1778 }
1779
1780
1781 static wxBitmap *new_wxBitmap(PyObject *listOfStrings){
1782 char** cArray = NULL;
1783 wxBitmap* bmp;
1784
1785 cArray = ConvertListOfStrings(listOfStrings);
1786 if (! cArray)
1787 return NULL;
1788 bmp = new wxBitmap(cArray);
1789 delete [] cArray;
1790 return bmp;
1791 }
1792 static wxBitmap *new_wxBitmap(PyObject *bits,int width,int height,int depth=1){
1793 char* buf;
1794 int length;
1795 PyString_AsStringAndSize(bits, &buf, &length);
1796 return new wxBitmap(buf, width, height, depth);
1797 }
1798
1799 SWIGINTERNSHORT long
1800 SWIG_As_long(PyObject* obj)
1801 {
1802 long v;
1803 if (!SWIG_AsVal_long(obj, &v)) {
1804 /*
1805 this is needed to make valgrind/purify happier.
1806 */
1807 memset((void*)&v, 0, sizeof(long));
1808 }
1809 return v;
1810 }
1811
1812
1813 SWIGINTERNSHORT int
1814 SWIG_Check_long(PyObject* obj)
1815 {
1816 return SWIG_AsVal_long(obj, (long*)0);
1817 }
1818
1819 static void wxBitmap_SetHandle(wxBitmap *self,long handle){ self->SetHandle((WXHANDLE)handle); }
1820 static wxSize wxBitmap_GetSize(wxBitmap *self){
1821 wxSize size(self->GetWidth(), self->GetHeight());
1822 return size;
1823 }
1824 static void wxBitmap_SetMaskColour(wxBitmap *self,wxColour const &colour){
1825 wxMask *mask = new wxMask(*self, colour);
1826 self->SetMask(mask);
1827 }
1828 static void wxBitmap_SetSize(wxBitmap *self,wxSize const &size){
1829 self->SetWidth(size.x);
1830 self->SetHeight(size.y);
1831 }
1832 static bool wxBitmap___eq__(wxBitmap *self,wxBitmap const *other){ return other ? (*self == *other) : false; }
1833 static bool wxBitmap___ne__(wxBitmap *self,wxBitmap const *other){ return other ? (*self != *other) : true; }
1834 static wxMask *new_wxMask(wxBitmap const &bitmap,wxColour const &colour=wxNullColour){
1835 if ( !colour.Ok() )
1836 return new wxMask(bitmap, *wxBLACK);
1837 else
1838 return new wxMask(bitmap, colour);
1839 }
1840
1841 #include <wx/iconbndl.h>
1842
1843 static wxIcon *new_wxIcon(wxBitmap const &bmp){
1844 wxIcon* icon = new wxIcon();
1845 icon->CopyFromBitmap(bmp);
1846 return icon;
1847 }
1848 static wxIcon *new_wxIcon(PyObject *listOfStrings){
1849 char** cArray = NULL;
1850 wxIcon* icon;
1851
1852 cArray = ConvertListOfStrings(listOfStrings);
1853 if (! cArray)
1854 return NULL;
1855 icon = new wxIcon(cArray);
1856 delete [] cArray;
1857 return icon;
1858 }
1859 static void wxIcon_SetHandle(wxIcon *self,long handle){ self->SetHandle((WXHANDLE)handle); }
1860 static wxIconLocation *new_wxIconLocation(wxString const *filename=&wxPyEmptyString,int num=0){
1861
1862 return new wxIconLocation(*filename, num);
1863
1864
1865
1866 }
1867 static void wxIconLocation_SetIndex(wxIconLocation *self,int num){
1868
1869 self->SetIndex(num);
1870
1871
1872
1873 }
1874 static int wxIconLocation_GetIndex(wxIconLocation *self){
1875
1876 return self->GetIndex();
1877
1878
1879
1880 }
1881 static wxCursor *new_wxCursor(wxString const &cursorName,long type,int hotSpotX=0,int hotSpotY=0){
1882 #ifdef __WXGTK__
1883 wxImage img(cursorName, type);
1884 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, hotSpotX);
1885 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, hotSpotY);
1886 return new wxCursor(img);
1887 #else
1888 return new wxCursor(cursorName, type, hotSpotX, hotSpotY);
1889 #endif
1890 }
1891 static void wxCursor_SetHandle(wxCursor *self,long handle){ self->SetHandle((WXHANDLE)handle); }
1892
1893
1894 static void wxRegionIterator_Next(wxRegionIterator *self){
1895 (*self) ++;
1896 }
1897 static bool wxRegionIterator___nonzero__(wxRegionIterator *self){
1898 return self->operator bool();
1899 }
1900
1901 #include <wx/fontutil.h>
1902 #include <wx/fontmap.h>
1903 #include <wx/fontenum.h>
1904
1905 static wxString wxNativeFontInfo___str__(wxNativeFontInfo *self){
1906 return self->ToString();
1907 }
1908
1909 wxNativeEncodingInfo* wxGetNativeFontEncoding(wxFontEncoding encoding)
1910 { wxPyRaiseNotImplemented(); return NULL; }
1911
1912 bool wxTestFontEncoding(const wxNativeEncodingInfo& info)
1913 { wxPyRaiseNotImplemented(); return false; }
1914
1915 static PyObject *wxFontMapper_GetAltForEncoding(wxFontMapper *self,wxFontEncoding encoding,wxString const &facename=wxPyEmptyString,bool interactive=true){
1916 wxFontEncoding alt_enc;
1917 if (self->GetAltForEncoding(encoding, &alt_enc, facename, interactive))
1918 return PyInt_FromLong(alt_enc);
1919 else {
1920 Py_INCREF(Py_None);
1921 return Py_None;
1922 }
1923 }
1924 static wxFont *new_wxFont(wxString const &info){
1925 wxNativeFontInfo nfi;
1926 nfi.FromString(info);
1927 return new wxFont(nfi);
1928 }
1929 static wxFont *new_wxFont(int pointSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxPyEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1930 return wxFont::New(pointSize, family, flags, face, encoding);
1931 }
1932 static wxFont *new_wxFont(wxSize const &pixelSize,int family,int style,int weight,bool underlined=false,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1933 return wxFontBase::New(pixelSize, family,
1934 style, weight, underlined,
1935 face, encoding);
1936 }
1937 static wxFont *new_wxFont(wxSize const &pixelSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1938 return wxFontBase::New(pixelSize, family, flags, face, encoding);
1939 }
1940 static bool wxFont___eq__(wxFont *self,wxFont const *other){ return other ? (*self == *other) : false; }
1941 static bool wxFont___ne__(wxFont *self,wxFont const *other){ return other ? (*self != *other) : true; }
1942
1943 class wxPyFontEnumerator : public wxFontEnumerator {
1944 public:
1945 wxPyFontEnumerator() {}
1946 ~wxPyFontEnumerator() {}
1947
1948 DEC_PYCALLBACK_BOOL_STRING(OnFacename);
1949 DEC_PYCALLBACK_BOOL_STRINGSTRING(OnFontEncoding);
1950
1951 PYPRIVATE;
1952 };
1953
1954 IMP_PYCALLBACK_BOOL_STRING(wxPyFontEnumerator, wxFontEnumerator, OnFacename);
1955 IMP_PYCALLBACK_BOOL_STRINGSTRING(wxPyFontEnumerator, wxFontEnumerator, OnFontEncoding);
1956
1957
1958 static PyObject *wxPyFontEnumerator_GetEncodings(wxPyFontEnumerator *self){
1959 wxArrayString* arr = self->GetEncodings();
1960 if (arr)
1961 return wxArrayString2PyList_helper(*arr);
1962 else
1963 return PyList_New(0);
1964 }
1965 static PyObject *wxPyFontEnumerator_GetFacenames(wxPyFontEnumerator *self){
1966 wxArrayString* arr = self->GetFacenames();
1967 if (arr)
1968 return wxArrayString2PyList_helper(*arr);
1969 else
1970 return PyList_New(0);
1971 }
1972
1973 #include <locale.h>
1974
1975 static wxLocale *new_wxLocale(int language=-1,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
1976 wxLocale* loc;
1977 if (language == -1)
1978 loc = new wxLocale();
1979 else
1980 loc = new wxLocale(language, flags);
1981 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1982 // for the floating point conversions and such to work right.
1983 #if PY_VERSION_HEX < 0x02040000
1984 setlocale(LC_NUMERIC, "C");
1985 #endif
1986 return loc;
1987 }
1988 static bool wxLocale_Init1(wxLocale *self,wxString const &szName,wxString const &szShort=wxPyEmptyString,wxString const &szLocale=wxPyEmptyString,bool bLoadDefault=true,bool bConvertEncoding=false){
1989 bool rc = self->Init(szName, szShort, szLocale, bLoadDefault, bConvertEncoding);
1990 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1991 // for the floating point conversions and such to work right.
1992 #if PY_VERSION_HEX < 0x02040000
1993 setlocale(LC_NUMERIC, "C");
1994 #endif
1995 return rc;
1996 }
1997 static bool wxLocale_Init2(wxLocale *self,int language=wxLANGUAGE_DEFAULT,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
1998 bool rc = self->Init(language, flags);
1999 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
2000 // for the floating point conversions and such to work right.
2001 #if PY_VERSION_HEX < 0x02040000
2002 setlocale(LC_NUMERIC, "C");
2003 #endif
2004 return rc;
2005 }
2006
2007 #include "wx/wxPython/pydrawxxx.h"
2008
2009 static wxColour wxDC_GetPixel(wxDC *self,int x,int y){
2010 wxColour col;
2011 self->GetPixel(x, y, &col);
2012 return col;
2013 }
2014 static wxColour wxDC_GetPixelPoint(wxDC *self,wxPoint const &pt){
2015 wxColour col;
2016 self->GetPixel(pt, &col);
2017 return col;
2018 }
2019
2020 SWIGINTERN int
2021 SWIG_AsVal_double(PyObject *obj, double* val)
2022 {
2023 if (PyNumber_Check(obj)) {
2024 if (val) *val = PyFloat_AsDouble(obj);
2025 return 1;
2026 }
2027 else {
2028 SWIG_type_error("number", obj);
2029 }
2030 return 0;
2031 }
2032
2033
2034 SWIGINTERNSHORT double
2035 SWIG_As_double(PyObject* obj)
2036 {
2037 double v;
2038 if (!SWIG_AsVal_double(obj, &v)) {
2039 /*
2040 this is needed to make valgrind/purify happier.
2041 */
2042 memset((void*)&v, 0, sizeof(double));
2043 }
2044 return v;
2045 }
2046
2047
2048 SWIGINTERNSHORT int
2049 SWIG_Check_double(PyObject* obj)
2050 {
2051 return SWIG_AsVal_double(obj, (double*)0);
2052 }
2053
2054 static wxRect wxDC_DrawImageLabel(wxDC *self,wxString const &text,wxBitmap const &image,wxRect const &rect,int alignment=wxALIGN_LEFT|wxALIGN_TOP,int indexAccel=-1){
2055 wxRect rv;
2056 self->DrawLabel(text, image, rect, alignment, indexAccel, &rv);
2057 return rv;
2058 }
2059
2060 static wxRect wxDC_GetClippingRect(wxDC *self){
2061 wxRect rect;
2062 self->GetClippingBox(rect);
2063 return rect;
2064 }
2065 static wxArrayInt wxDC_GetPartialTextExtents(wxDC *self,wxString const &text){
2066 wxArrayInt widths;
2067 self->GetPartialTextExtents(text, widths);
2068 return widths;
2069 }
2070
2071 /*@C:\\SWIG-1.3.24\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2072 #define SWIG_From_double PyFloat_FromDouble
2073 /*@@*/
2074
2075
2076 static void wxDC_SetLogicalOriginPoint(wxDC *self,wxPoint const &point){
2077 self->SetLogicalOrigin(point.x, point.y);
2078 }
2079 static void wxDC_SetDeviceOriginPoint(wxDC *self,wxPoint const &point){
2080 self->SetDeviceOrigin(point.x, point.y);
2081 }
2082 static void wxDC_CalcBoundingBoxPoint(wxDC *self,wxPoint const &point){
2083 self->CalcBoundingBox(point.x, point.y);
2084 }
2085 static PyObject *wxDC__DrawPointList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2086 return wxPyDrawXXXList(*self, wxPyDrawXXXPoint, pyCoords, pyPens, pyBrushes);
2087 }
2088 static PyObject *wxDC__DrawLineList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2089 return wxPyDrawXXXList(*self, wxPyDrawXXXLine, pyCoords, pyPens, pyBrushes);
2090 }
2091 static PyObject *wxDC__DrawRectangleList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2092 return wxPyDrawXXXList(*self, wxPyDrawXXXRectangle, pyCoords, pyPens, pyBrushes);
2093 }
2094 static PyObject *wxDC__DrawEllipseList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2095 return wxPyDrawXXXList(*self, wxPyDrawXXXEllipse, pyCoords, pyPens, pyBrushes);
2096 }
2097 static PyObject *wxDC__DrawPolygonList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2098 return wxPyDrawXXXList(*self, wxPyDrawXXXPolygon, pyCoords, pyPens, pyBrushes);
2099 }
2100 static PyObject *wxDC__DrawTextList(wxDC *self,PyObject *textList,PyObject *pyPoints,PyObject *foregroundList,PyObject *backgroundList){
2101 return wxPyDrawTextList(*self, textList, pyPoints, foregroundList, backgroundList);
2102 }
2103
2104 static void wxDC_GetBoundingBox(wxDC* dc, int* x1, int* y1, int* x2, int* y2) {
2105 *x1 = dc->MinX();
2106 *y1 = dc->MinY();
2107 *x2 = dc->MaxX();
2108 *y2 = dc->MaxY();
2109 }
2110
2111
2112 #include <wx/dcbuffer.h>
2113
2114
2115 #include <wx/dcps.h>
2116
2117
2118 #include <wx/metafile.h>
2119
2120
2121
2122 static void wxColourDatabase_Append(wxColourDatabase *self,wxString const &name,int red,int green,int blue){
2123 self->AddColour(name, wxColour(red, green, blue));
2124 }
2125
2126 #include <wx/effects.h>
2127
2128
2129 #include "wx/renderer.h"
2130
2131
2132 SWIGINTERNSHORT PyObject*
2133 SWIG_From_bool(bool value)
2134 {
2135 PyObject *obj = value ? Py_True : Py_False;
2136 Py_INCREF(obj);
2137 return obj;
2138 }
2139
2140 #ifdef __cplusplus
2141 extern "C" {
2142 #endif
2143 static PyObject *_wrap_new_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2144 PyObject *resultobj;
2145 wxGDIObject *result;
2146 char *kwnames[] = {
2147 NULL
2148 };
2149
2150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GDIObject",kwnames)) goto fail;
2151 {
2152 if (!wxPyCheckForApp()) SWIG_fail;
2153 PyThreadState* __tstate = wxPyBeginAllowThreads();
2154 result = (wxGDIObject *)new wxGDIObject();
2155
2156 wxPyEndAllowThreads(__tstate);
2157 if (PyErr_Occurred()) SWIG_fail;
2158 }
2159 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGDIObject, 1);
2160 return resultobj;
2161 fail:
2162 return NULL;
2163 }
2164
2165
2166 static PyObject *_wrap_delete_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2167 PyObject *resultobj;
2168 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2169 PyObject * obj0 = 0 ;
2170 char *kwnames[] = {
2171 (char *) "self", NULL
2172 };
2173
2174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GDIObject",kwnames,&obj0)) goto fail;
2175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2176 if (SWIG_arg_fail(1)) SWIG_fail;
2177 {
2178 PyThreadState* __tstate = wxPyBeginAllowThreads();
2179 delete arg1;
2180
2181 wxPyEndAllowThreads(__tstate);
2182 if (PyErr_Occurred()) SWIG_fail;
2183 }
2184 Py_INCREF(Py_None); resultobj = Py_None;
2185 return resultobj;
2186 fail:
2187 return NULL;
2188 }
2189
2190
2191 static PyObject *_wrap_GDIObject_GetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2192 PyObject *resultobj;
2193 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2194 bool result;
2195 PyObject * obj0 = 0 ;
2196 char *kwnames[] = {
2197 (char *) "self", NULL
2198 };
2199
2200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_GetVisible",kwnames,&obj0)) goto fail;
2201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2202 if (SWIG_arg_fail(1)) SWIG_fail;
2203 {
2204 PyThreadState* __tstate = wxPyBeginAllowThreads();
2205 result = (bool)(arg1)->GetVisible();
2206
2207 wxPyEndAllowThreads(__tstate);
2208 if (PyErr_Occurred()) SWIG_fail;
2209 }
2210 {
2211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2212 }
2213 return resultobj;
2214 fail:
2215 return NULL;
2216 }
2217
2218
2219 static PyObject *_wrap_GDIObject_SetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2220 PyObject *resultobj;
2221 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2222 bool arg2 ;
2223 PyObject * obj0 = 0 ;
2224 PyObject * obj1 = 0 ;
2225 char *kwnames[] = {
2226 (char *) "self",(char *) "visible", NULL
2227 };
2228
2229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GDIObject_SetVisible",kwnames,&obj0,&obj1)) goto fail;
2230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2231 if (SWIG_arg_fail(1)) SWIG_fail;
2232 {
2233 arg2 = (bool)(SWIG_As_bool(obj1));
2234 if (SWIG_arg_fail(2)) SWIG_fail;
2235 }
2236 {
2237 PyThreadState* __tstate = wxPyBeginAllowThreads();
2238 (arg1)->SetVisible(arg2);
2239
2240 wxPyEndAllowThreads(__tstate);
2241 if (PyErr_Occurred()) SWIG_fail;
2242 }
2243 Py_INCREF(Py_None); resultobj = Py_None;
2244 return resultobj;
2245 fail:
2246 return NULL;
2247 }
2248
2249
2250 static PyObject *_wrap_GDIObject_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
2251 PyObject *resultobj;
2252 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2253 bool result;
2254 PyObject * obj0 = 0 ;
2255 char *kwnames[] = {
2256 (char *) "self", NULL
2257 };
2258
2259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_IsNull",kwnames,&obj0)) goto fail;
2260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2261 if (SWIG_arg_fail(1)) SWIG_fail;
2262 {
2263 PyThreadState* __tstate = wxPyBeginAllowThreads();
2264 result = (bool)(arg1)->IsNull();
2265
2266 wxPyEndAllowThreads(__tstate);
2267 if (PyErr_Occurred()) SWIG_fail;
2268 }
2269 {
2270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2271 }
2272 return resultobj;
2273 fail:
2274 return NULL;
2275 }
2276
2277
2278 static PyObject * GDIObject_swigregister(PyObject *, PyObject *args) {
2279 PyObject *obj;
2280 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2281 SWIG_TypeClientData(SWIGTYPE_p_wxGDIObject, obj);
2282 Py_INCREF(obj);
2283 return Py_BuildValue((char *)"");
2284 }
2285 static PyObject *_wrap_new_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2286 PyObject *resultobj;
2287 byte arg1 = (byte) 0 ;
2288 byte arg2 = (byte) 0 ;
2289 byte arg3 = (byte) 0 ;
2290 wxColour *result;
2291 PyObject * obj0 = 0 ;
2292 PyObject * obj1 = 0 ;
2293 PyObject * obj2 = 0 ;
2294 char *kwnames[] = {
2295 (char *) "red",(char *) "green",(char *) "blue", NULL
2296 };
2297
2298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Colour",kwnames,&obj0,&obj1,&obj2)) goto fail;
2299 if (obj0) {
2300 {
2301 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
2302 if (SWIG_arg_fail(1)) SWIG_fail;
2303 }
2304 }
2305 if (obj1) {
2306 {
2307 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2308 if (SWIG_arg_fail(2)) SWIG_fail;
2309 }
2310 }
2311 if (obj2) {
2312 {
2313 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2314 if (SWIG_arg_fail(3)) SWIG_fail;
2315 }
2316 }
2317 {
2318 PyThreadState* __tstate = wxPyBeginAllowThreads();
2319 result = (wxColour *)new wxColour(arg1,arg2,arg3);
2320
2321 wxPyEndAllowThreads(__tstate);
2322 if (PyErr_Occurred()) SWIG_fail;
2323 }
2324 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2325 return resultobj;
2326 fail:
2327 return NULL;
2328 }
2329
2330
2331 static PyObject *_wrap_new_NamedColour(PyObject *, PyObject *args, PyObject *kwargs) {
2332 PyObject *resultobj;
2333 wxString *arg1 = 0 ;
2334 wxColour *result;
2335 bool temp1 = false ;
2336 PyObject * obj0 = 0 ;
2337 char *kwnames[] = {
2338 (char *) "colorName", NULL
2339 };
2340
2341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_NamedColour",kwnames,&obj0)) goto fail;
2342 {
2343 arg1 = wxString_in_helper(obj0);
2344 if (arg1 == NULL) SWIG_fail;
2345 temp1 = true;
2346 }
2347 {
2348 if (!wxPyCheckForApp()) SWIG_fail;
2349 PyThreadState* __tstate = wxPyBeginAllowThreads();
2350 result = (wxColour *)new wxColour((wxString const &)*arg1);
2351
2352 wxPyEndAllowThreads(__tstate);
2353 if (PyErr_Occurred()) SWIG_fail;
2354 }
2355 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2356 {
2357 if (temp1)
2358 delete arg1;
2359 }
2360 return resultobj;
2361 fail:
2362 {
2363 if (temp1)
2364 delete arg1;
2365 }
2366 return NULL;
2367 }
2368
2369
2370 static PyObject *_wrap_new_ColourRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2371 PyObject *resultobj;
2372 unsigned long arg1 ;
2373 wxColour *result;
2374 PyObject * obj0 = 0 ;
2375 char *kwnames[] = {
2376 (char *) "colRGB", NULL
2377 };
2378
2379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ColourRGB",kwnames,&obj0)) goto fail;
2380 {
2381 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
2382 if (SWIG_arg_fail(1)) SWIG_fail;
2383 }
2384 {
2385 PyThreadState* __tstate = wxPyBeginAllowThreads();
2386 result = (wxColour *)new wxColour(arg1);
2387
2388 wxPyEndAllowThreads(__tstate);
2389 if (PyErr_Occurred()) SWIG_fail;
2390 }
2391 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2392 return resultobj;
2393 fail:
2394 return NULL;
2395 }
2396
2397
2398 static PyObject *_wrap_delete_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2399 PyObject *resultobj;
2400 wxColour *arg1 = (wxColour *) 0 ;
2401 PyObject * obj0 = 0 ;
2402 char *kwnames[] = {
2403 (char *) "self", NULL
2404 };
2405
2406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Colour",kwnames,&obj0)) goto fail;
2407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2408 if (SWIG_arg_fail(1)) SWIG_fail;
2409 {
2410 PyThreadState* __tstate = wxPyBeginAllowThreads();
2411 delete arg1;
2412
2413 wxPyEndAllowThreads(__tstate);
2414 if (PyErr_Occurred()) SWIG_fail;
2415 }
2416 Py_INCREF(Py_None); resultobj = Py_None;
2417 return resultobj;
2418 fail:
2419 return NULL;
2420 }
2421
2422
2423 static PyObject *_wrap_Colour_Red(PyObject *, PyObject *args, PyObject *kwargs) {
2424 PyObject *resultobj;
2425 wxColour *arg1 = (wxColour *) 0 ;
2426 byte result;
2427 PyObject * obj0 = 0 ;
2428 char *kwnames[] = {
2429 (char *) "self", NULL
2430 };
2431
2432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Red",kwnames,&obj0)) goto fail;
2433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2434 if (SWIG_arg_fail(1)) SWIG_fail;
2435 {
2436 PyThreadState* __tstate = wxPyBeginAllowThreads();
2437 result = (byte)(arg1)->Red();
2438
2439 wxPyEndAllowThreads(__tstate);
2440 if (PyErr_Occurred()) SWIG_fail;
2441 }
2442 {
2443 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2444 }
2445 return resultobj;
2446 fail:
2447 return NULL;
2448 }
2449
2450
2451 static PyObject *_wrap_Colour_Green(PyObject *, PyObject *args, PyObject *kwargs) {
2452 PyObject *resultobj;
2453 wxColour *arg1 = (wxColour *) 0 ;
2454 byte result;
2455 PyObject * obj0 = 0 ;
2456 char *kwnames[] = {
2457 (char *) "self", NULL
2458 };
2459
2460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Green",kwnames,&obj0)) goto fail;
2461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2462 if (SWIG_arg_fail(1)) SWIG_fail;
2463 {
2464 PyThreadState* __tstate = wxPyBeginAllowThreads();
2465 result = (byte)(arg1)->Green();
2466
2467 wxPyEndAllowThreads(__tstate);
2468 if (PyErr_Occurred()) SWIG_fail;
2469 }
2470 {
2471 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2472 }
2473 return resultobj;
2474 fail:
2475 return NULL;
2476 }
2477
2478
2479 static PyObject *_wrap_Colour_Blue(PyObject *, PyObject *args, PyObject *kwargs) {
2480 PyObject *resultobj;
2481 wxColour *arg1 = (wxColour *) 0 ;
2482 byte result;
2483 PyObject * obj0 = 0 ;
2484 char *kwnames[] = {
2485 (char *) "self", NULL
2486 };
2487
2488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Blue",kwnames,&obj0)) goto fail;
2489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2490 if (SWIG_arg_fail(1)) SWIG_fail;
2491 {
2492 PyThreadState* __tstate = wxPyBeginAllowThreads();
2493 result = (byte)(arg1)->Blue();
2494
2495 wxPyEndAllowThreads(__tstate);
2496 if (PyErr_Occurred()) SWIG_fail;
2497 }
2498 {
2499 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2500 }
2501 return resultobj;
2502 fail:
2503 return NULL;
2504 }
2505
2506
2507 static PyObject *_wrap_Colour_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
2508 PyObject *resultobj;
2509 wxColour *arg1 = (wxColour *) 0 ;
2510 bool result;
2511 PyObject * obj0 = 0 ;
2512 char *kwnames[] = {
2513 (char *) "self", NULL
2514 };
2515
2516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Ok",kwnames,&obj0)) goto fail;
2517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2518 if (SWIG_arg_fail(1)) SWIG_fail;
2519 {
2520 PyThreadState* __tstate = wxPyBeginAllowThreads();
2521 result = (bool)(arg1)->Ok();
2522
2523 wxPyEndAllowThreads(__tstate);
2524 if (PyErr_Occurred()) SWIG_fail;
2525 }
2526 {
2527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2528 }
2529 return resultobj;
2530 fail:
2531 return NULL;
2532 }
2533
2534
2535 static PyObject *_wrap_Colour_Set(PyObject *, PyObject *args, PyObject *kwargs) {
2536 PyObject *resultobj;
2537 wxColour *arg1 = (wxColour *) 0 ;
2538 byte arg2 ;
2539 byte arg3 ;
2540 byte arg4 ;
2541 PyObject * obj0 = 0 ;
2542 PyObject * obj1 = 0 ;
2543 PyObject * obj2 = 0 ;
2544 PyObject * obj3 = 0 ;
2545 char *kwnames[] = {
2546 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2547 };
2548
2549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Colour_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2551 if (SWIG_arg_fail(1)) SWIG_fail;
2552 {
2553 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2554 if (SWIG_arg_fail(2)) SWIG_fail;
2555 }
2556 {
2557 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2558 if (SWIG_arg_fail(3)) SWIG_fail;
2559 }
2560 {
2561 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2562 if (SWIG_arg_fail(4)) SWIG_fail;
2563 }
2564 {
2565 PyThreadState* __tstate = wxPyBeginAllowThreads();
2566 (arg1)->Set(arg2,arg3,arg4);
2567
2568 wxPyEndAllowThreads(__tstate);
2569 if (PyErr_Occurred()) SWIG_fail;
2570 }
2571 Py_INCREF(Py_None); resultobj = Py_None;
2572 return resultobj;
2573 fail:
2574 return NULL;
2575 }
2576
2577
2578 static PyObject *_wrap_Colour_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2579 PyObject *resultobj;
2580 wxColour *arg1 = (wxColour *) 0 ;
2581 unsigned long arg2 ;
2582 PyObject * obj0 = 0 ;
2583 PyObject * obj1 = 0 ;
2584 char *kwnames[] = {
2585 (char *) "self",(char *) "colRGB", NULL
2586 };
2587
2588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetRGB",kwnames,&obj0,&obj1)) goto fail;
2589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2590 if (SWIG_arg_fail(1)) SWIG_fail;
2591 {
2592 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
2593 if (SWIG_arg_fail(2)) SWIG_fail;
2594 }
2595 {
2596 PyThreadState* __tstate = wxPyBeginAllowThreads();
2597 (arg1)->Set(arg2);
2598
2599 wxPyEndAllowThreads(__tstate);
2600 if (PyErr_Occurred()) SWIG_fail;
2601 }
2602 Py_INCREF(Py_None); resultobj = Py_None;
2603 return resultobj;
2604 fail:
2605 return NULL;
2606 }
2607
2608
2609 static PyObject *_wrap_Colour_SetFromName(PyObject *, PyObject *args, PyObject *kwargs) {
2610 PyObject *resultobj;
2611 wxColour *arg1 = (wxColour *) 0 ;
2612 wxString *arg2 = 0 ;
2613 bool temp2 = false ;
2614 PyObject * obj0 = 0 ;
2615 PyObject * obj1 = 0 ;
2616 char *kwnames[] = {
2617 (char *) "self",(char *) "colourName", NULL
2618 };
2619
2620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetFromName",kwnames,&obj0,&obj1)) goto fail;
2621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2622 if (SWIG_arg_fail(1)) SWIG_fail;
2623 {
2624 arg2 = wxString_in_helper(obj1);
2625 if (arg2 == NULL) SWIG_fail;
2626 temp2 = true;
2627 }
2628 {
2629 PyThreadState* __tstate = wxPyBeginAllowThreads();
2630 (arg1)->InitFromName((wxString const &)*arg2);
2631
2632 wxPyEndAllowThreads(__tstate);
2633 if (PyErr_Occurred()) SWIG_fail;
2634 }
2635 Py_INCREF(Py_None); resultobj = Py_None;
2636 {
2637 if (temp2)
2638 delete arg2;
2639 }
2640 return resultobj;
2641 fail:
2642 {
2643 if (temp2)
2644 delete arg2;
2645 }
2646 return NULL;
2647 }
2648
2649
2650 static PyObject *_wrap_Colour_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2651 PyObject *resultobj;
2652 wxColour *arg1 = (wxColour *) 0 ;
2653 long result;
2654 PyObject * obj0 = 0 ;
2655 char *kwnames[] = {
2656 (char *) "self", NULL
2657 };
2658
2659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetPixel",kwnames,&obj0)) goto fail;
2660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2661 if (SWIG_arg_fail(1)) SWIG_fail;
2662 {
2663 PyThreadState* __tstate = wxPyBeginAllowThreads();
2664 result = (long)((wxColour const *)arg1)->GetPixel();
2665
2666 wxPyEndAllowThreads(__tstate);
2667 if (PyErr_Occurred()) SWIG_fail;
2668 }
2669 {
2670 resultobj = SWIG_From_long((long)(result));
2671 }
2672 return resultobj;
2673 fail:
2674 return NULL;
2675 }
2676
2677
2678 static PyObject *_wrap_Colour___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
2679 PyObject *resultobj;
2680 wxColour *arg1 = (wxColour *) 0 ;
2681 wxColour *arg2 = 0 ;
2682 bool result;
2683 wxColour temp2 ;
2684 PyObject * obj0 = 0 ;
2685 PyObject * obj1 = 0 ;
2686 char *kwnames[] = {
2687 (char *) "self",(char *) "colour", NULL
2688 };
2689
2690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___eq__",kwnames,&obj0,&obj1)) goto fail;
2691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2692 if (SWIG_arg_fail(1)) SWIG_fail;
2693 {
2694 arg2 = &temp2;
2695 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2696 }
2697 {
2698 PyThreadState* __tstate = wxPyBeginAllowThreads();
2699 result = (bool)((wxColour const *)arg1)->operator ==((wxColour const &)*arg2);
2700
2701 wxPyEndAllowThreads(__tstate);
2702 if (PyErr_Occurred()) SWIG_fail;
2703 }
2704 {
2705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2706 }
2707 return resultobj;
2708 fail:
2709 return NULL;
2710 }
2711
2712
2713 static PyObject *_wrap_Colour___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
2714 PyObject *resultobj;
2715 wxColour *arg1 = (wxColour *) 0 ;
2716 wxColour *arg2 = 0 ;
2717 bool result;
2718 wxColour temp2 ;
2719 PyObject * obj0 = 0 ;
2720 PyObject * obj1 = 0 ;
2721 char *kwnames[] = {
2722 (char *) "self",(char *) "colour", NULL
2723 };
2724
2725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___ne__",kwnames,&obj0,&obj1)) goto fail;
2726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2727 if (SWIG_arg_fail(1)) SWIG_fail;
2728 {
2729 arg2 = &temp2;
2730 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2731 }
2732 {
2733 PyThreadState* __tstate = wxPyBeginAllowThreads();
2734 result = (bool)((wxColour const *)arg1)->operator !=((wxColour const &)*arg2);
2735
2736 wxPyEndAllowThreads(__tstate);
2737 if (PyErr_Occurred()) SWIG_fail;
2738 }
2739 {
2740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2741 }
2742 return resultobj;
2743 fail:
2744 return NULL;
2745 }
2746
2747
2748 static PyObject *_wrap_Colour_Get(PyObject *, PyObject *args, PyObject *kwargs) {
2749 PyObject *resultobj;
2750 wxColour *arg1 = (wxColour *) 0 ;
2751 PyObject *result;
2752 PyObject * obj0 = 0 ;
2753 char *kwnames[] = {
2754 (char *) "self", NULL
2755 };
2756
2757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Get",kwnames,&obj0)) goto fail;
2758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2759 if (SWIG_arg_fail(1)) SWIG_fail;
2760 {
2761 PyThreadState* __tstate = wxPyBeginAllowThreads();
2762 result = (PyObject *)wxColour_Get(arg1);
2763
2764 wxPyEndAllowThreads(__tstate);
2765 if (PyErr_Occurred()) SWIG_fail;
2766 }
2767 resultobj = result;
2768 return resultobj;
2769 fail:
2770 return NULL;
2771 }
2772
2773
2774 static PyObject *_wrap_Colour_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2775 PyObject *resultobj;
2776 wxColour *arg1 = (wxColour *) 0 ;
2777 unsigned long result;
2778 PyObject * obj0 = 0 ;
2779 char *kwnames[] = {
2780 (char *) "self", NULL
2781 };
2782
2783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetRGB",kwnames,&obj0)) goto fail;
2784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2785 if (SWIG_arg_fail(1)) SWIG_fail;
2786 {
2787 PyThreadState* __tstate = wxPyBeginAllowThreads();
2788 result = (unsigned long)wxColour_GetRGB(arg1);
2789
2790 wxPyEndAllowThreads(__tstate);
2791 if (PyErr_Occurred()) SWIG_fail;
2792 }
2793 {
2794 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
2795 }
2796 return resultobj;
2797 fail:
2798 return NULL;
2799 }
2800
2801
2802 static PyObject * Colour_swigregister(PyObject *, PyObject *args) {
2803 PyObject *obj;
2804 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2805 SWIG_TypeClientData(SWIGTYPE_p_wxColour, obj);
2806 Py_INCREF(obj);
2807 return Py_BuildValue((char *)"");
2808 }
2809 static PyObject *_wrap_new_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2810 PyObject *resultobj;
2811 int arg1 ;
2812 unsigned char *arg2 = (unsigned char *) 0 ;
2813 unsigned char *arg3 = (unsigned char *) 0 ;
2814 unsigned char *arg4 = (unsigned char *) 0 ;
2815 wxPalette *result;
2816 PyObject * obj0 = 0 ;
2817 PyObject * obj1 = 0 ;
2818 PyObject * obj2 = 0 ;
2819 PyObject * obj3 = 0 ;
2820 char *kwnames[] = {
2821 (char *) "n",(char *) "red",(char *) "green",(char *) "blue", NULL
2822 };
2823
2824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_Palette",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2825 {
2826 arg1 = (int)(SWIG_As_int(obj0));
2827 if (SWIG_arg_fail(1)) SWIG_fail;
2828 }
2829 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2830 if (SWIG_arg_fail(2)) SWIG_fail;
2831 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2832 if (SWIG_arg_fail(3)) SWIG_fail;
2833 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2834 if (SWIG_arg_fail(4)) SWIG_fail;
2835 {
2836 if (!wxPyCheckForApp()) SWIG_fail;
2837 PyThreadState* __tstate = wxPyBeginAllowThreads();
2838 result = (wxPalette *)new wxPalette(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
2839
2840 wxPyEndAllowThreads(__tstate);
2841 if (PyErr_Occurred()) SWIG_fail;
2842 }
2843 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 1);
2844 return resultobj;
2845 fail:
2846 return NULL;
2847 }
2848
2849
2850 static PyObject *_wrap_delete_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2851 PyObject *resultobj;
2852 wxPalette *arg1 = (wxPalette *) 0 ;
2853 PyObject * obj0 = 0 ;
2854 char *kwnames[] = {
2855 (char *) "self", NULL
2856 };
2857
2858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Palette",kwnames,&obj0)) goto fail;
2859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2860 if (SWIG_arg_fail(1)) SWIG_fail;
2861 {
2862 PyThreadState* __tstate = wxPyBeginAllowThreads();
2863 delete arg1;
2864
2865 wxPyEndAllowThreads(__tstate);
2866 if (PyErr_Occurred()) SWIG_fail;
2867 }
2868 Py_INCREF(Py_None); resultobj = Py_None;
2869 return resultobj;
2870 fail:
2871 return NULL;
2872 }
2873
2874
2875 static PyObject *_wrap_Palette_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2876 PyObject *resultobj;
2877 wxPalette *arg1 = (wxPalette *) 0 ;
2878 byte arg2 ;
2879 byte arg3 ;
2880 byte arg4 ;
2881 int result;
2882 PyObject * obj0 = 0 ;
2883 PyObject * obj1 = 0 ;
2884 PyObject * obj2 = 0 ;
2885 PyObject * obj3 = 0 ;
2886 char *kwnames[] = {
2887 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2888 };
2889
2890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Palette_GetPixel",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2892 if (SWIG_arg_fail(1)) SWIG_fail;
2893 {
2894 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2895 if (SWIG_arg_fail(2)) SWIG_fail;
2896 }
2897 {
2898 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2899 if (SWIG_arg_fail(3)) SWIG_fail;
2900 }
2901 {
2902 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2903 if (SWIG_arg_fail(4)) SWIG_fail;
2904 }
2905 {
2906 PyThreadState* __tstate = wxPyBeginAllowThreads();
2907 result = (int)(arg1)->GetPixel(arg2,arg3,arg4);
2908
2909 wxPyEndAllowThreads(__tstate);
2910 if (PyErr_Occurred()) SWIG_fail;
2911 }
2912 {
2913 resultobj = SWIG_From_int((int)(result));
2914 }
2915 return resultobj;
2916 fail:
2917 return NULL;
2918 }
2919
2920
2921 static PyObject *_wrap_Palette_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2922 PyObject *resultobj;
2923 wxPalette *arg1 = (wxPalette *) 0 ;
2924 int arg2 ;
2925 byte *arg3 = (byte *) 0 ;
2926 byte *arg4 = (byte *) 0 ;
2927 byte *arg5 = (byte *) 0 ;
2928 bool result;
2929 byte temp3 ;
2930 int res3 = 0 ;
2931 byte temp4 ;
2932 int res4 = 0 ;
2933 byte temp5 ;
2934 int res5 = 0 ;
2935 PyObject * obj0 = 0 ;
2936 PyObject * obj1 = 0 ;
2937 char *kwnames[] = {
2938 (char *) "self",(char *) "pixel", NULL
2939 };
2940
2941 arg3 = &temp3; res3 = SWIG_NEWOBJ;
2942 arg4 = &temp4; res4 = SWIG_NEWOBJ;
2943 arg5 = &temp5; res5 = SWIG_NEWOBJ;
2944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Palette_GetRGB",kwnames,&obj0,&obj1)) goto fail;
2945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2946 if (SWIG_arg_fail(1)) SWIG_fail;
2947 {
2948 arg2 = (int)(SWIG_As_int(obj1));
2949 if (SWIG_arg_fail(2)) SWIG_fail;
2950 }
2951 {
2952 PyThreadState* __tstate = wxPyBeginAllowThreads();
2953 result = (bool)(arg1)->GetRGB(arg2,arg3,arg4,arg5);
2954
2955 wxPyEndAllowThreads(__tstate);
2956 if (PyErr_Occurred()) SWIG_fail;
2957 }
2958 {
2959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2960 }
2961 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
2962 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
2963 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
2964 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
2965 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
2966 SWIG_From_unsigned_SS_char((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_unsigned_char, 0)));
2967 return resultobj;
2968 fail:
2969 return NULL;
2970 }
2971
2972
2973 static PyObject *_wrap_Palette_GetColoursCount(PyObject *, PyObject *args, PyObject *kwargs) {
2974 PyObject *resultobj;
2975 wxPalette *arg1 = (wxPalette *) 0 ;
2976 int result;
2977 PyObject * obj0 = 0 ;
2978 char *kwnames[] = {
2979 (char *) "self", NULL
2980 };
2981
2982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_GetColoursCount",kwnames,&obj0)) goto fail;
2983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2984 if (SWIG_arg_fail(1)) SWIG_fail;
2985 {
2986 PyThreadState* __tstate = wxPyBeginAllowThreads();
2987 result = (int)((wxPalette const *)arg1)->GetColoursCount();
2988
2989 wxPyEndAllowThreads(__tstate);
2990 if (PyErr_Occurred()) SWIG_fail;
2991 }
2992 {
2993 resultobj = SWIG_From_int((int)(result));
2994 }
2995 return resultobj;
2996 fail:
2997 return NULL;
2998 }
2999
3000
3001 static PyObject *_wrap_Palette_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3002 PyObject *resultobj;
3003 wxPalette *arg1 = (wxPalette *) 0 ;
3004 bool result;
3005 PyObject * obj0 = 0 ;
3006 char *kwnames[] = {
3007 (char *) "self", NULL
3008 };
3009
3010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_Ok",kwnames,&obj0)) goto fail;
3011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
3012 if (SWIG_arg_fail(1)) SWIG_fail;
3013 {
3014 PyThreadState* __tstate = wxPyBeginAllowThreads();
3015 result = (bool)(arg1)->Ok();
3016
3017 wxPyEndAllowThreads(__tstate);
3018 if (PyErr_Occurred()) SWIG_fail;
3019 }
3020 {
3021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3022 }
3023 return resultobj;
3024 fail:
3025 return NULL;
3026 }
3027
3028
3029 static PyObject * Palette_swigregister(PyObject *, PyObject *args) {
3030 PyObject *obj;
3031 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3032 SWIG_TypeClientData(SWIGTYPE_p_wxPalette, obj);
3033 Py_INCREF(obj);
3034 return Py_BuildValue((char *)"");
3035 }
3036 static PyObject *_wrap_new_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3037 PyObject *resultobj;
3038 wxColour *arg1 = 0 ;
3039 int arg2 = (int) 1 ;
3040 int arg3 = (int) wxSOLID ;
3041 wxPen *result;
3042 wxColour temp1 ;
3043 PyObject * obj0 = 0 ;
3044 PyObject * obj1 = 0 ;
3045 PyObject * obj2 = 0 ;
3046 char *kwnames[] = {
3047 (char *) "colour",(char *) "width",(char *) "style", NULL
3048 };
3049
3050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Pen",kwnames,&obj0,&obj1,&obj2)) goto fail;
3051 {
3052 arg1 = &temp1;
3053 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3054 }
3055 if (obj1) {
3056 {
3057 arg2 = (int)(SWIG_As_int(obj1));
3058 if (SWIG_arg_fail(2)) SWIG_fail;
3059 }
3060 }
3061 if (obj2) {
3062 {
3063 arg3 = (int)(SWIG_As_int(obj2));
3064 if (SWIG_arg_fail(3)) SWIG_fail;
3065 }
3066 }
3067 {
3068 if (!wxPyCheckForApp()) SWIG_fail;
3069 PyThreadState* __tstate = wxPyBeginAllowThreads();
3070 result = (wxPen *)new wxPen(*arg1,arg2,arg3);
3071
3072 wxPyEndAllowThreads(__tstate);
3073 if (PyErr_Occurred()) SWIG_fail;
3074 }
3075 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 1);
3076 return resultobj;
3077 fail:
3078 return NULL;
3079 }
3080
3081
3082 static PyObject *_wrap_delete_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3083 PyObject *resultobj;
3084 wxPen *arg1 = (wxPen *) 0 ;
3085 PyObject * obj0 = 0 ;
3086 char *kwnames[] = {
3087 (char *) "self", NULL
3088 };
3089
3090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Pen",kwnames,&obj0)) goto fail;
3091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3092 if (SWIG_arg_fail(1)) SWIG_fail;
3093 {
3094 PyThreadState* __tstate = wxPyBeginAllowThreads();
3095 delete arg1;
3096
3097 wxPyEndAllowThreads(__tstate);
3098 if (PyErr_Occurred()) SWIG_fail;
3099 }
3100 Py_INCREF(Py_None); resultobj = Py_None;
3101 return resultobj;
3102 fail:
3103 return NULL;
3104 }
3105
3106
3107 static PyObject *_wrap_Pen_GetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3108 PyObject *resultobj;
3109 wxPen *arg1 = (wxPen *) 0 ;
3110 int result;
3111 PyObject * obj0 = 0 ;
3112 char *kwnames[] = {
3113 (char *) "self", NULL
3114 };
3115
3116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetCap",kwnames,&obj0)) goto fail;
3117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3118 if (SWIG_arg_fail(1)) SWIG_fail;
3119 {
3120 PyThreadState* __tstate = wxPyBeginAllowThreads();
3121 result = (int)(arg1)->GetCap();
3122
3123 wxPyEndAllowThreads(__tstate);
3124 if (PyErr_Occurred()) SWIG_fail;
3125 }
3126 {
3127 resultobj = SWIG_From_int((int)(result));
3128 }
3129 return resultobj;
3130 fail:
3131 return NULL;
3132 }
3133
3134
3135 static PyObject *_wrap_Pen_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3136 PyObject *resultobj;
3137 wxPen *arg1 = (wxPen *) 0 ;
3138 wxColour result;
3139 PyObject * obj0 = 0 ;
3140 char *kwnames[] = {
3141 (char *) "self", NULL
3142 };
3143
3144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetColour",kwnames,&obj0)) goto fail;
3145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3146 if (SWIG_arg_fail(1)) SWIG_fail;
3147 {
3148 PyThreadState* __tstate = wxPyBeginAllowThreads();
3149 result = (arg1)->GetColour();
3150
3151 wxPyEndAllowThreads(__tstate);
3152 if (PyErr_Occurred()) SWIG_fail;
3153 }
3154 {
3155 wxColour * resultptr;
3156 resultptr = new wxColour((wxColour &)(result));
3157 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3158 }
3159 return resultobj;
3160 fail:
3161 return NULL;
3162 }
3163
3164
3165 static PyObject *_wrap_Pen_GetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3166 PyObject *resultobj;
3167 wxPen *arg1 = (wxPen *) 0 ;
3168 int result;
3169 PyObject * obj0 = 0 ;
3170 char *kwnames[] = {
3171 (char *) "self", NULL
3172 };
3173
3174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetJoin",kwnames,&obj0)) goto fail;
3175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3176 if (SWIG_arg_fail(1)) SWIG_fail;
3177 {
3178 PyThreadState* __tstate = wxPyBeginAllowThreads();
3179 result = (int)(arg1)->GetJoin();
3180
3181 wxPyEndAllowThreads(__tstate);
3182 if (PyErr_Occurred()) SWIG_fail;
3183 }
3184 {
3185 resultobj = SWIG_From_int((int)(result));
3186 }
3187 return resultobj;
3188 fail:
3189 return NULL;
3190 }
3191
3192
3193 static PyObject *_wrap_Pen_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3194 PyObject *resultobj;
3195 wxPen *arg1 = (wxPen *) 0 ;
3196 int result;
3197 PyObject * obj0 = 0 ;
3198 char *kwnames[] = {
3199 (char *) "self", NULL
3200 };
3201
3202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetStyle",kwnames,&obj0)) goto fail;
3203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3204 if (SWIG_arg_fail(1)) SWIG_fail;
3205 {
3206 PyThreadState* __tstate = wxPyBeginAllowThreads();
3207 result = (int)(arg1)->GetStyle();
3208
3209 wxPyEndAllowThreads(__tstate);
3210 if (PyErr_Occurred()) SWIG_fail;
3211 }
3212 {
3213 resultobj = SWIG_From_int((int)(result));
3214 }
3215 return resultobj;
3216 fail:
3217 return NULL;
3218 }
3219
3220
3221 static PyObject *_wrap_Pen_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3222 PyObject *resultobj;
3223 wxPen *arg1 = (wxPen *) 0 ;
3224 int result;
3225 PyObject * obj0 = 0 ;
3226 char *kwnames[] = {
3227 (char *) "self", NULL
3228 };
3229
3230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetWidth",kwnames,&obj0)) goto fail;
3231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3232 if (SWIG_arg_fail(1)) SWIG_fail;
3233 {
3234 PyThreadState* __tstate = wxPyBeginAllowThreads();
3235 result = (int)(arg1)->GetWidth();
3236
3237 wxPyEndAllowThreads(__tstate);
3238 if (PyErr_Occurred()) SWIG_fail;
3239 }
3240 {
3241 resultobj = SWIG_From_int((int)(result));
3242 }
3243 return resultobj;
3244 fail:
3245 return NULL;
3246 }
3247
3248
3249 static PyObject *_wrap_Pen_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3250 PyObject *resultobj;
3251 wxPen *arg1 = (wxPen *) 0 ;
3252 bool result;
3253 PyObject * obj0 = 0 ;
3254 char *kwnames[] = {
3255 (char *) "self", NULL
3256 };
3257
3258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_Ok",kwnames,&obj0)) goto fail;
3259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3260 if (SWIG_arg_fail(1)) SWIG_fail;
3261 {
3262 PyThreadState* __tstate = wxPyBeginAllowThreads();
3263 result = (bool)(arg1)->Ok();
3264
3265 wxPyEndAllowThreads(__tstate);
3266 if (PyErr_Occurred()) SWIG_fail;
3267 }
3268 {
3269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3270 }
3271 return resultobj;
3272 fail:
3273 return NULL;
3274 }
3275
3276
3277 static PyObject *_wrap_Pen_SetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3278 PyObject *resultobj;
3279 wxPen *arg1 = (wxPen *) 0 ;
3280 int arg2 ;
3281 PyObject * obj0 = 0 ;
3282 PyObject * obj1 = 0 ;
3283 char *kwnames[] = {
3284 (char *) "self",(char *) "cap_style", NULL
3285 };
3286
3287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetCap",kwnames,&obj0,&obj1)) goto fail;
3288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3289 if (SWIG_arg_fail(1)) SWIG_fail;
3290 {
3291 arg2 = (int)(SWIG_As_int(obj1));
3292 if (SWIG_arg_fail(2)) SWIG_fail;
3293 }
3294 {
3295 PyThreadState* __tstate = wxPyBeginAllowThreads();
3296 (arg1)->SetCap(arg2);
3297
3298 wxPyEndAllowThreads(__tstate);
3299 if (PyErr_Occurred()) SWIG_fail;
3300 }
3301 Py_INCREF(Py_None); resultobj = Py_None;
3302 return resultobj;
3303 fail:
3304 return NULL;
3305 }
3306
3307
3308 static PyObject *_wrap_Pen_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3309 PyObject *resultobj;
3310 wxPen *arg1 = (wxPen *) 0 ;
3311 wxColour *arg2 = 0 ;
3312 wxColour temp2 ;
3313 PyObject * obj0 = 0 ;
3314 PyObject * obj1 = 0 ;
3315 char *kwnames[] = {
3316 (char *) "self",(char *) "colour", NULL
3317 };
3318
3319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetColour",kwnames,&obj0,&obj1)) goto fail;
3320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3321 if (SWIG_arg_fail(1)) SWIG_fail;
3322 {
3323 arg2 = &temp2;
3324 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3325 }
3326 {
3327 PyThreadState* __tstate = wxPyBeginAllowThreads();
3328 (arg1)->SetColour(*arg2);
3329
3330 wxPyEndAllowThreads(__tstate);
3331 if (PyErr_Occurred()) SWIG_fail;
3332 }
3333 Py_INCREF(Py_None); resultobj = Py_None;
3334 return resultobj;
3335 fail:
3336 return NULL;
3337 }
3338
3339
3340 static PyObject *_wrap_Pen_SetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3341 PyObject *resultobj;
3342 wxPen *arg1 = (wxPen *) 0 ;
3343 int arg2 ;
3344 PyObject * obj0 = 0 ;
3345 PyObject * obj1 = 0 ;
3346 char *kwnames[] = {
3347 (char *) "self",(char *) "join_style", NULL
3348 };
3349
3350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetJoin",kwnames,&obj0,&obj1)) goto fail;
3351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3352 if (SWIG_arg_fail(1)) SWIG_fail;
3353 {
3354 arg2 = (int)(SWIG_As_int(obj1));
3355 if (SWIG_arg_fail(2)) SWIG_fail;
3356 }
3357 {
3358 PyThreadState* __tstate = wxPyBeginAllowThreads();
3359 (arg1)->SetJoin(arg2);
3360
3361 wxPyEndAllowThreads(__tstate);
3362 if (PyErr_Occurred()) SWIG_fail;
3363 }
3364 Py_INCREF(Py_None); resultobj = Py_None;
3365 return resultobj;
3366 fail:
3367 return NULL;
3368 }
3369
3370
3371 static PyObject *_wrap_Pen_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3372 PyObject *resultobj;
3373 wxPen *arg1 = (wxPen *) 0 ;
3374 int arg2 ;
3375 PyObject * obj0 = 0 ;
3376 PyObject * obj1 = 0 ;
3377 char *kwnames[] = {
3378 (char *) "self",(char *) "style", NULL
3379 };
3380
3381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3383 if (SWIG_arg_fail(1)) SWIG_fail;
3384 {
3385 arg2 = (int)(SWIG_As_int(obj1));
3386 if (SWIG_arg_fail(2)) SWIG_fail;
3387 }
3388 {
3389 PyThreadState* __tstate = wxPyBeginAllowThreads();
3390 (arg1)->SetStyle(arg2);
3391
3392 wxPyEndAllowThreads(__tstate);
3393 if (PyErr_Occurred()) SWIG_fail;
3394 }
3395 Py_INCREF(Py_None); resultobj = Py_None;
3396 return resultobj;
3397 fail:
3398 return NULL;
3399 }
3400
3401
3402 static PyObject *_wrap_Pen_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3403 PyObject *resultobj;
3404 wxPen *arg1 = (wxPen *) 0 ;
3405 int arg2 ;
3406 PyObject * obj0 = 0 ;
3407 PyObject * obj1 = 0 ;
3408 char *kwnames[] = {
3409 (char *) "self",(char *) "width", NULL
3410 };
3411
3412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3414 if (SWIG_arg_fail(1)) SWIG_fail;
3415 {
3416 arg2 = (int)(SWIG_As_int(obj1));
3417 if (SWIG_arg_fail(2)) SWIG_fail;
3418 }
3419 {
3420 PyThreadState* __tstate = wxPyBeginAllowThreads();
3421 (arg1)->SetWidth(arg2);
3422
3423 wxPyEndAllowThreads(__tstate);
3424 if (PyErr_Occurred()) SWIG_fail;
3425 }
3426 Py_INCREF(Py_None); resultobj = Py_None;
3427 return resultobj;
3428 fail:
3429 return NULL;
3430 }
3431
3432
3433 static PyObject *_wrap_Pen_SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3434 PyObject *resultobj;
3435 wxPen *arg1 = (wxPen *) 0 ;
3436 int arg2 ;
3437 wxDash *arg3 = (wxDash *) 0 ;
3438 PyObject * obj0 = 0 ;
3439 PyObject * obj1 = 0 ;
3440 char *kwnames[] = {
3441 (char *) "self",(char *) "dashes", NULL
3442 };
3443
3444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetDashes",kwnames,&obj0,&obj1)) goto fail;
3445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3446 if (SWIG_arg_fail(1)) SWIG_fail;
3447 {
3448 arg2 = PyList_Size(obj1);
3449 arg3 = (wxDash*)byte_LIST_helper(obj1);
3450 if (arg3 == NULL) SWIG_fail;
3451 }
3452 {
3453 PyThreadState* __tstate = wxPyBeginAllowThreads();
3454 (arg1)->SetDashes(arg2,arg3);
3455
3456 wxPyEndAllowThreads(__tstate);
3457 if (PyErr_Occurred()) SWIG_fail;
3458 }
3459 Py_INCREF(Py_None); resultobj = Py_None;
3460 {
3461 if (arg3) delete [] arg3;
3462 }
3463 return resultobj;
3464 fail:
3465 {
3466 if (arg3) delete [] arg3;
3467 }
3468 return NULL;
3469 }
3470
3471
3472 static PyObject *_wrap_Pen_GetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3473 PyObject *resultobj;
3474 wxPen *arg1 = (wxPen *) 0 ;
3475 PyObject *result;
3476 PyObject * obj0 = 0 ;
3477 char *kwnames[] = {
3478 (char *) "self", NULL
3479 };
3480
3481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashes",kwnames,&obj0)) goto fail;
3482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3483 if (SWIG_arg_fail(1)) SWIG_fail;
3484 {
3485 PyThreadState* __tstate = wxPyBeginAllowThreads();
3486 result = (PyObject *)wxPen_GetDashes(arg1);
3487
3488 wxPyEndAllowThreads(__tstate);
3489 if (PyErr_Occurred()) SWIG_fail;
3490 }
3491 resultobj = result;
3492 return resultobj;
3493 fail:
3494 return NULL;
3495 }
3496
3497
3498 static PyObject *_wrap_Pen__SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3499 PyObject *resultobj;
3500 wxPen *arg1 = (wxPen *) 0 ;
3501 PyObject *arg2 = (PyObject *) 0 ;
3502 PyObject *arg3 = (PyObject *) 0 ;
3503 PyObject * obj0 = 0 ;
3504 PyObject * obj1 = 0 ;
3505 PyObject * obj2 = 0 ;
3506 char *kwnames[] = {
3507 (char *) "self",(char *) "_self",(char *) "pyDashes", NULL
3508 };
3509
3510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Pen__SetDashes",kwnames,&obj0,&obj1,&obj2)) goto fail;
3511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3512 if (SWIG_arg_fail(1)) SWIG_fail;
3513 arg2 = obj1;
3514 arg3 = obj2;
3515 {
3516 PyThreadState* __tstate = wxPyBeginAllowThreads();
3517 wxPen__SetDashes(arg1,arg2,arg3);
3518
3519 wxPyEndAllowThreads(__tstate);
3520 if (PyErr_Occurred()) SWIG_fail;
3521 }
3522 Py_INCREF(Py_None); resultobj = Py_None;
3523 return resultobj;
3524 fail:
3525 return NULL;
3526 }
3527
3528
3529 static PyObject *_wrap_Pen_GetDashCount(PyObject *, PyObject *args, PyObject *kwargs) {
3530 PyObject *resultobj;
3531 wxPen *arg1 = (wxPen *) 0 ;
3532 int result;
3533 PyObject * obj0 = 0 ;
3534 char *kwnames[] = {
3535 (char *) "self", NULL
3536 };
3537
3538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashCount",kwnames,&obj0)) goto fail;
3539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3540 if (SWIG_arg_fail(1)) SWIG_fail;
3541 {
3542 PyThreadState* __tstate = wxPyBeginAllowThreads();
3543 result = (int)((wxPen const *)arg1)->GetDashCount();
3544
3545 wxPyEndAllowThreads(__tstate);
3546 if (PyErr_Occurred()) SWIG_fail;
3547 }
3548 {
3549 resultobj = SWIG_From_int((int)(result));
3550 }
3551 return resultobj;
3552 fail:
3553 return NULL;
3554 }
3555
3556
3557 static PyObject *_wrap_Pen_GetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3558 PyObject *resultobj;
3559 wxPen *arg1 = (wxPen *) 0 ;
3560 wxBitmap *result;
3561 PyObject * obj0 = 0 ;
3562 char *kwnames[] = {
3563 (char *) "self", NULL
3564 };
3565
3566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetStipple",kwnames,&obj0)) 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 {
3570 PyThreadState* __tstate = wxPyBeginAllowThreads();
3571 result = (wxBitmap *)(arg1)->GetStipple();
3572
3573 wxPyEndAllowThreads(__tstate);
3574 if (PyErr_Occurred()) SWIG_fail;
3575 }
3576 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 0);
3577 return resultobj;
3578 fail:
3579 return NULL;
3580 }
3581
3582
3583 static PyObject *_wrap_Pen_SetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3584 PyObject *resultobj;
3585 wxPen *arg1 = (wxPen *) 0 ;
3586 wxBitmap *arg2 = 0 ;
3587 PyObject * obj0 = 0 ;
3588 PyObject * obj1 = 0 ;
3589 char *kwnames[] = {
3590 (char *) "self",(char *) "stipple", NULL
3591 };
3592
3593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStipple",kwnames,&obj0,&obj1)) goto fail;
3594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3595 if (SWIG_arg_fail(1)) SWIG_fail;
3596 {
3597 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3598 if (SWIG_arg_fail(2)) SWIG_fail;
3599 if (arg2 == NULL) {
3600 SWIG_null_ref("wxBitmap");
3601 }
3602 if (SWIG_arg_fail(2)) SWIG_fail;
3603 }
3604 {
3605 PyThreadState* __tstate = wxPyBeginAllowThreads();
3606 (arg1)->SetStipple(*arg2);
3607
3608 wxPyEndAllowThreads(__tstate);
3609 if (PyErr_Occurred()) SWIG_fail;
3610 }
3611 Py_INCREF(Py_None); resultobj = Py_None;
3612 return resultobj;
3613 fail:
3614 return NULL;
3615 }
3616
3617
3618 static PyObject *_wrap_Pen___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3619 PyObject *resultobj;
3620 wxPen *arg1 = (wxPen *) 0 ;
3621 wxPen *arg2 = (wxPen *) 0 ;
3622 bool result;
3623 PyObject * obj0 = 0 ;
3624 PyObject * obj1 = 0 ;
3625 char *kwnames[] = {
3626 (char *) "self",(char *) "other", NULL
3627 };
3628
3629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___eq__",kwnames,&obj0,&obj1)) goto fail;
3630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3631 if (SWIG_arg_fail(1)) SWIG_fail;
3632 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3633 if (SWIG_arg_fail(2)) SWIG_fail;
3634 {
3635 PyThreadState* __tstate = wxPyBeginAllowThreads();
3636 result = (bool)wxPen___eq__(arg1,(wxPen const *)arg2);
3637
3638 wxPyEndAllowThreads(__tstate);
3639 if (PyErr_Occurred()) SWIG_fail;
3640 }
3641 {
3642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3643 }
3644 return resultobj;
3645 fail:
3646 return NULL;
3647 }
3648
3649
3650 static PyObject *_wrap_Pen___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3651 PyObject *resultobj;
3652 wxPen *arg1 = (wxPen *) 0 ;
3653 wxPen *arg2 = (wxPen *) 0 ;
3654 bool result;
3655 PyObject * obj0 = 0 ;
3656 PyObject * obj1 = 0 ;
3657 char *kwnames[] = {
3658 (char *) "self",(char *) "other", NULL
3659 };
3660
3661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___ne__",kwnames,&obj0,&obj1)) goto fail;
3662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3663 if (SWIG_arg_fail(1)) SWIG_fail;
3664 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3665 if (SWIG_arg_fail(2)) SWIG_fail;
3666 {
3667 PyThreadState* __tstate = wxPyBeginAllowThreads();
3668 result = (bool)wxPen___ne__(arg1,(wxPen const *)arg2);
3669
3670 wxPyEndAllowThreads(__tstate);
3671 if (PyErr_Occurred()) SWIG_fail;
3672 }
3673 {
3674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3675 }
3676 return resultobj;
3677 fail:
3678 return NULL;
3679 }
3680
3681
3682 static PyObject * Pen_swigregister(PyObject *, PyObject *args) {
3683 PyObject *obj;
3684 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3685 SWIG_TypeClientData(SWIGTYPE_p_wxPen, obj);
3686 Py_INCREF(obj);
3687 return Py_BuildValue((char *)"");
3688 }
3689 static PyObject *_wrap_new_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3690 PyObject *resultobj;
3691 wxColour *arg1 = 0 ;
3692 int arg2 = (int) wxSOLID ;
3693 wxBrush *result;
3694 wxColour temp1 ;
3695 PyObject * obj0 = 0 ;
3696 PyObject * obj1 = 0 ;
3697 char *kwnames[] = {
3698 (char *) "colour",(char *) "style", NULL
3699 };
3700
3701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Brush",kwnames,&obj0,&obj1)) goto fail;
3702 {
3703 arg1 = &temp1;
3704 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3705 }
3706 if (obj1) {
3707 {
3708 arg2 = (int)(SWIG_As_int(obj1));
3709 if (SWIG_arg_fail(2)) SWIG_fail;
3710 }
3711 }
3712 {
3713 if (!wxPyCheckForApp()) SWIG_fail;
3714 PyThreadState* __tstate = wxPyBeginAllowThreads();
3715 result = (wxBrush *)new wxBrush((wxColour const &)*arg1,arg2);
3716
3717 wxPyEndAllowThreads(__tstate);
3718 if (PyErr_Occurred()) SWIG_fail;
3719 }
3720 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 1);
3721 return resultobj;
3722 fail:
3723 return NULL;
3724 }
3725
3726
3727 static PyObject *_wrap_new_BrushFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
3728 PyObject *resultobj;
3729 wxBitmap *arg1 = 0 ;
3730 wxBrush *result;
3731 PyObject * obj0 = 0 ;
3732 char *kwnames[] = {
3733 (char *) "stippleBitmap", NULL
3734 };
3735
3736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BrushFromBitmap",kwnames,&obj0)) goto fail;
3737 {
3738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3739 if (SWIG_arg_fail(1)) SWIG_fail;
3740 if (arg1 == NULL) {
3741 SWIG_null_ref("wxBitmap");
3742 }
3743 if (SWIG_arg_fail(1)) SWIG_fail;
3744 }
3745 {
3746 if (!wxPyCheckForApp()) SWIG_fail;
3747 PyThreadState* __tstate = wxPyBeginAllowThreads();
3748 result = (wxBrush *)new wxBrush((wxBitmap const &)*arg1);
3749
3750 wxPyEndAllowThreads(__tstate);
3751 if (PyErr_Occurred()) SWIG_fail;
3752 }
3753 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 1);
3754 return resultobj;
3755 fail:
3756 return NULL;
3757 }
3758
3759
3760 static PyObject *_wrap_delete_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3761 PyObject *resultobj;
3762 wxBrush *arg1 = (wxBrush *) 0 ;
3763 PyObject * obj0 = 0 ;
3764 char *kwnames[] = {
3765 (char *) "self", NULL
3766 };
3767
3768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Brush",kwnames,&obj0)) goto fail;
3769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3770 if (SWIG_arg_fail(1)) SWIG_fail;
3771 {
3772 PyThreadState* __tstate = wxPyBeginAllowThreads();
3773 delete arg1;
3774
3775 wxPyEndAllowThreads(__tstate);
3776 if (PyErr_Occurred()) SWIG_fail;
3777 }
3778 Py_INCREF(Py_None); resultobj = Py_None;
3779 return resultobj;
3780 fail:
3781 return NULL;
3782 }
3783
3784
3785 static PyObject *_wrap_Brush_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3786 PyObject *resultobj;
3787 wxBrush *arg1 = (wxBrush *) 0 ;
3788 wxColour *arg2 = 0 ;
3789 wxColour temp2 ;
3790 PyObject * obj0 = 0 ;
3791 PyObject * obj1 = 0 ;
3792 char *kwnames[] = {
3793 (char *) "self",(char *) "col", NULL
3794 };
3795
3796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetColour",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
3801 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3802 }
3803 {
3804 PyThreadState* __tstate = wxPyBeginAllowThreads();
3805 (arg1)->SetColour((wxColour const &)*arg2);
3806
3807 wxPyEndAllowThreads(__tstate);
3808 if (PyErr_Occurred()) SWIG_fail;
3809 }
3810 Py_INCREF(Py_None); resultobj = Py_None;
3811 return resultobj;
3812 fail:
3813 return NULL;
3814 }
3815
3816
3817 static PyObject *_wrap_Brush_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3818 PyObject *resultobj;
3819 wxBrush *arg1 = (wxBrush *) 0 ;
3820 int arg2 ;
3821 PyObject * obj0 = 0 ;
3822 PyObject * obj1 = 0 ;
3823 char *kwnames[] = {
3824 (char *) "self",(char *) "style", NULL
3825 };
3826
3827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3829 if (SWIG_arg_fail(1)) SWIG_fail;
3830 {
3831 arg2 = (int)(SWIG_As_int(obj1));
3832 if (SWIG_arg_fail(2)) SWIG_fail;
3833 }
3834 {
3835 PyThreadState* __tstate = wxPyBeginAllowThreads();
3836 (arg1)->SetStyle(arg2);
3837
3838 wxPyEndAllowThreads(__tstate);
3839 if (PyErr_Occurred()) SWIG_fail;
3840 }
3841 Py_INCREF(Py_None); resultobj = Py_None;
3842 return resultobj;
3843 fail:
3844 return NULL;
3845 }
3846
3847
3848 static PyObject *_wrap_Brush_SetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3849 PyObject *resultobj;
3850 wxBrush *arg1 = (wxBrush *) 0 ;
3851 wxBitmap *arg2 = 0 ;
3852 PyObject * obj0 = 0 ;
3853 PyObject * obj1 = 0 ;
3854 char *kwnames[] = {
3855 (char *) "self",(char *) "stipple", NULL
3856 };
3857
3858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStipple",kwnames,&obj0,&obj1)) goto fail;
3859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3860 if (SWIG_arg_fail(1)) SWIG_fail;
3861 {
3862 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3863 if (SWIG_arg_fail(2)) SWIG_fail;
3864 if (arg2 == NULL) {
3865 SWIG_null_ref("wxBitmap");
3866 }
3867 if (SWIG_arg_fail(2)) SWIG_fail;
3868 }
3869 {
3870 PyThreadState* __tstate = wxPyBeginAllowThreads();
3871 (arg1)->SetStipple((wxBitmap const &)*arg2);
3872
3873 wxPyEndAllowThreads(__tstate);
3874 if (PyErr_Occurred()) SWIG_fail;
3875 }
3876 Py_INCREF(Py_None); resultobj = Py_None;
3877 return resultobj;
3878 fail:
3879 return NULL;
3880 }
3881
3882
3883 static PyObject *_wrap_Brush_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3884 PyObject *resultobj;
3885 wxBrush *arg1 = (wxBrush *) 0 ;
3886 wxColour result;
3887 PyObject * obj0 = 0 ;
3888 char *kwnames[] = {
3889 (char *) "self", NULL
3890 };
3891
3892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetColour",kwnames,&obj0)) goto fail;
3893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3894 if (SWIG_arg_fail(1)) SWIG_fail;
3895 {
3896 PyThreadState* __tstate = wxPyBeginAllowThreads();
3897 result = ((wxBrush const *)arg1)->GetColour();
3898
3899 wxPyEndAllowThreads(__tstate);
3900 if (PyErr_Occurred()) SWIG_fail;
3901 }
3902 {
3903 wxColour * resultptr;
3904 resultptr = new wxColour((wxColour &)(result));
3905 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3906 }
3907 return resultobj;
3908 fail:
3909 return NULL;
3910 }
3911
3912
3913 static PyObject *_wrap_Brush_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3914 PyObject *resultobj;
3915 wxBrush *arg1 = (wxBrush *) 0 ;
3916 int result;
3917 PyObject * obj0 = 0 ;
3918 char *kwnames[] = {
3919 (char *) "self", NULL
3920 };
3921
3922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStyle",kwnames,&obj0)) goto fail;
3923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3924 if (SWIG_arg_fail(1)) SWIG_fail;
3925 {
3926 PyThreadState* __tstate = wxPyBeginAllowThreads();
3927 result = (int)((wxBrush const *)arg1)->GetStyle();
3928
3929 wxPyEndAllowThreads(__tstate);
3930 if (PyErr_Occurred()) SWIG_fail;
3931 }
3932 {
3933 resultobj = SWIG_From_int((int)(result));
3934 }
3935 return resultobj;
3936 fail:
3937 return NULL;
3938 }
3939
3940
3941 static PyObject *_wrap_Brush_GetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3942 PyObject *resultobj;
3943 wxBrush *arg1 = (wxBrush *) 0 ;
3944 wxBitmap *result;
3945 PyObject * obj0 = 0 ;
3946 char *kwnames[] = {
3947 (char *) "self", NULL
3948 };
3949
3950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStipple",kwnames,&obj0)) goto fail;
3951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3952 if (SWIG_arg_fail(1)) SWIG_fail;
3953 {
3954 PyThreadState* __tstate = wxPyBeginAllowThreads();
3955 result = (wxBitmap *)((wxBrush const *)arg1)->GetStipple();
3956
3957 wxPyEndAllowThreads(__tstate);
3958 if (PyErr_Occurred()) SWIG_fail;
3959 }
3960 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 0);
3961 return resultobj;
3962 fail:
3963 return NULL;
3964 }
3965
3966
3967 static PyObject *_wrap_Brush_IsHatch(PyObject *, PyObject *args, PyObject *kwargs) {
3968 PyObject *resultobj;
3969 wxBrush *arg1 = (wxBrush *) 0 ;
3970 bool result;
3971 PyObject * obj0 = 0 ;
3972 char *kwnames[] = {
3973 (char *) "self", NULL
3974 };
3975
3976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_IsHatch",kwnames,&obj0)) goto fail;
3977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3978 if (SWIG_arg_fail(1)) SWIG_fail;
3979 {
3980 PyThreadState* __tstate = wxPyBeginAllowThreads();
3981 result = (bool)((wxBrush const *)arg1)->IsHatch();
3982
3983 wxPyEndAllowThreads(__tstate);
3984 if (PyErr_Occurred()) SWIG_fail;
3985 }
3986 {
3987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3988 }
3989 return resultobj;
3990 fail:
3991 return NULL;
3992 }
3993
3994
3995 static PyObject *_wrap_Brush_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3996 PyObject *resultobj;
3997 wxBrush *arg1 = (wxBrush *) 0 ;
3998 bool result;
3999 PyObject * obj0 = 0 ;
4000 char *kwnames[] = {
4001 (char *) "self", NULL
4002 };
4003
4004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_Ok",kwnames,&obj0)) goto fail;
4005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
4006 if (SWIG_arg_fail(1)) SWIG_fail;
4007 {
4008 PyThreadState* __tstate = wxPyBeginAllowThreads();
4009 result = (bool)(arg1)->Ok();
4010
4011 wxPyEndAllowThreads(__tstate);
4012 if (PyErr_Occurred()) SWIG_fail;
4013 }
4014 {
4015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4016 }
4017 return resultobj;
4018 fail:
4019 return NULL;
4020 }
4021
4022
4023 static PyObject * Brush_swigregister(PyObject *, PyObject *args) {
4024 PyObject *obj;
4025 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4026 SWIG_TypeClientData(SWIGTYPE_p_wxBrush, obj);
4027 Py_INCREF(obj);
4028 return Py_BuildValue((char *)"");
4029 }
4030 static PyObject *_wrap_new_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4031 PyObject *resultobj;
4032 wxString *arg1 = 0 ;
4033 wxBitmapType arg2 = (wxBitmapType) wxBITMAP_TYPE_ANY ;
4034 wxBitmap *result;
4035 bool temp1 = false ;
4036 PyObject * obj0 = 0 ;
4037 PyObject * obj1 = 0 ;
4038 char *kwnames[] = {
4039 (char *) "name",(char *) "type", NULL
4040 };
4041
4042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Bitmap",kwnames,&obj0,&obj1)) goto fail;
4043 {
4044 arg1 = wxString_in_helper(obj0);
4045 if (arg1 == NULL) SWIG_fail;
4046 temp1 = true;
4047 }
4048 if (obj1) {
4049 {
4050 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
4051 if (SWIG_arg_fail(2)) SWIG_fail;
4052 }
4053 }
4054 {
4055 if (!wxPyCheckForApp()) SWIG_fail;
4056 PyThreadState* __tstate = wxPyBeginAllowThreads();
4057 result = (wxBitmap *)new wxBitmap((wxString const &)*arg1,(wxBitmapType )arg2);
4058
4059 wxPyEndAllowThreads(__tstate);
4060 if (PyErr_Occurred()) SWIG_fail;
4061 }
4062 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4063 {
4064 if (temp1)
4065 delete arg1;
4066 }
4067 return resultobj;
4068 fail:
4069 {
4070 if (temp1)
4071 delete arg1;
4072 }
4073 return NULL;
4074 }
4075
4076
4077 static PyObject *_wrap_delete_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4078 PyObject *resultobj;
4079 wxBitmap *arg1 = (wxBitmap *) 0 ;
4080 PyObject * obj0 = 0 ;
4081 char *kwnames[] = {
4082 (char *) "self", NULL
4083 };
4084
4085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Bitmap",kwnames,&obj0)) goto fail;
4086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4087 if (SWIG_arg_fail(1)) SWIG_fail;
4088 {
4089 PyThreadState* __tstate = wxPyBeginAllowThreads();
4090 delete arg1;
4091
4092 wxPyEndAllowThreads(__tstate);
4093 if (PyErr_Occurred()) SWIG_fail;
4094 }
4095 Py_INCREF(Py_None); resultobj = Py_None;
4096 return resultobj;
4097 fail:
4098 return NULL;
4099 }
4100
4101
4102 static PyObject *_wrap_new_EmptyBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4103 PyObject *resultobj;
4104 int arg1 ;
4105 int arg2 ;
4106 int arg3 = (int) -1 ;
4107 wxBitmap *result;
4108 PyObject * obj0 = 0 ;
4109 PyObject * obj1 = 0 ;
4110 PyObject * obj2 = 0 ;
4111 char *kwnames[] = {
4112 (char *) "width",(char *) "height",(char *) "depth", NULL
4113 };
4114
4115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_EmptyBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
4116 {
4117 arg1 = (int)(SWIG_As_int(obj0));
4118 if (SWIG_arg_fail(1)) SWIG_fail;
4119 }
4120 {
4121 arg2 = (int)(SWIG_As_int(obj1));
4122 if (SWIG_arg_fail(2)) SWIG_fail;
4123 }
4124 if (obj2) {
4125 {
4126 arg3 = (int)(SWIG_As_int(obj2));
4127 if (SWIG_arg_fail(3)) SWIG_fail;
4128 }
4129 }
4130 {
4131 if (!wxPyCheckForApp()) SWIG_fail;
4132 PyThreadState* __tstate = wxPyBeginAllowThreads();
4133 result = (wxBitmap *)new wxBitmap(arg1,arg2,arg3);
4134
4135 wxPyEndAllowThreads(__tstate);
4136 if (PyErr_Occurred()) SWIG_fail;
4137 }
4138 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4139 return resultobj;
4140 fail:
4141 return NULL;
4142 }
4143
4144
4145 static PyObject *_wrap_new_BitmapFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4146 PyObject *resultobj;
4147 wxIcon *arg1 = 0 ;
4148 wxBitmap *result;
4149 PyObject * obj0 = 0 ;
4150 char *kwnames[] = {
4151 (char *) "icon", NULL
4152 };
4153
4154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromIcon",kwnames,&obj0)) goto fail;
4155 {
4156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4157 if (SWIG_arg_fail(1)) SWIG_fail;
4158 if (arg1 == NULL) {
4159 SWIG_null_ref("wxIcon");
4160 }
4161 if (SWIG_arg_fail(1)) SWIG_fail;
4162 }
4163 {
4164 if (!wxPyCheckForApp()) SWIG_fail;
4165 PyThreadState* __tstate = wxPyBeginAllowThreads();
4166 result = (wxBitmap *)new wxBitmap((wxIcon const &)*arg1);
4167
4168 wxPyEndAllowThreads(__tstate);
4169 if (PyErr_Occurred()) SWIG_fail;
4170 }
4171 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4172 return resultobj;
4173 fail:
4174 return NULL;
4175 }
4176
4177
4178 static PyObject *_wrap_new_BitmapFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
4179 PyObject *resultobj;
4180 wxImage *arg1 = 0 ;
4181 int arg2 = (int) -1 ;
4182 wxBitmap *result;
4183 PyObject * obj0 = 0 ;
4184 PyObject * obj1 = 0 ;
4185 char *kwnames[] = {
4186 (char *) "image",(char *) "depth", NULL
4187 };
4188
4189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BitmapFromImage",kwnames,&obj0,&obj1)) goto fail;
4190 {
4191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
4192 if (SWIG_arg_fail(1)) SWIG_fail;
4193 if (arg1 == NULL) {
4194 SWIG_null_ref("wxImage");
4195 }
4196 if (SWIG_arg_fail(1)) SWIG_fail;
4197 }
4198 if (obj1) {
4199 {
4200 arg2 = (int)(SWIG_As_int(obj1));
4201 if (SWIG_arg_fail(2)) SWIG_fail;
4202 }
4203 }
4204 {
4205 if (!wxPyCheckForApp()) SWIG_fail;
4206 PyThreadState* __tstate = wxPyBeginAllowThreads();
4207 result = (wxBitmap *)new wxBitmap((wxImage const &)*arg1,arg2);
4208
4209 wxPyEndAllowThreads(__tstate);
4210 if (PyErr_Occurred()) SWIG_fail;
4211 }
4212 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4213 return resultobj;
4214 fail:
4215 return NULL;
4216 }
4217
4218
4219 static PyObject *_wrap_new_BitmapFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
4220 PyObject *resultobj;
4221 PyObject *arg1 = (PyObject *) 0 ;
4222 wxBitmap *result;
4223 PyObject * obj0 = 0 ;
4224 char *kwnames[] = {
4225 (char *) "listOfStrings", NULL
4226 };
4227
4228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromXPMData",kwnames,&obj0)) goto fail;
4229 arg1 = obj0;
4230 {
4231 if (!wxPyCheckForApp()) SWIG_fail;
4232 PyThreadState* __tstate = wxPyBeginAllowThreads();
4233 result = (wxBitmap *)new_wxBitmap(arg1);
4234
4235 wxPyEndAllowThreads(__tstate);
4236 if (PyErr_Occurred()) SWIG_fail;
4237 }
4238 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4239 return resultobj;
4240 fail:
4241 return NULL;
4242 }
4243
4244
4245 static PyObject *_wrap_new_BitmapFromBits(PyObject *, PyObject *args, PyObject *kwargs) {
4246 PyObject *resultobj;
4247 PyObject *arg1 = (PyObject *) 0 ;
4248 int arg2 ;
4249 int arg3 ;
4250 int arg4 = (int) 1 ;
4251 wxBitmap *result;
4252 PyObject * obj0 = 0 ;
4253 PyObject * obj1 = 0 ;
4254 PyObject * obj2 = 0 ;
4255 PyObject * obj3 = 0 ;
4256 char *kwnames[] = {
4257 (char *) "bits",(char *) "width",(char *) "height",(char *) "depth", NULL
4258 };
4259
4260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:new_BitmapFromBits",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4261 arg1 = obj0;
4262 {
4263 arg2 = (int)(SWIG_As_int(obj1));
4264 if (SWIG_arg_fail(2)) SWIG_fail;
4265 }
4266 {
4267 arg3 = (int)(SWIG_As_int(obj2));
4268 if (SWIG_arg_fail(3)) SWIG_fail;
4269 }
4270 if (obj3) {
4271 {
4272 arg4 = (int)(SWIG_As_int(obj3));
4273 if (SWIG_arg_fail(4)) SWIG_fail;
4274 }
4275 }
4276 {
4277 if (!wxPyCheckForApp()) SWIG_fail;
4278 PyThreadState* __tstate = wxPyBeginAllowThreads();
4279 result = (wxBitmap *)new_wxBitmap(arg1,arg2,arg3,arg4);
4280
4281 wxPyEndAllowThreads(__tstate);
4282 if (PyErr_Occurred()) SWIG_fail;
4283 }
4284 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4285 return resultobj;
4286 fail:
4287 return NULL;
4288 }
4289
4290
4291 static PyObject *_wrap_Bitmap_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
4292 PyObject *resultobj;
4293 wxBitmap *arg1 = (wxBitmap *) 0 ;
4294 long result;
4295 PyObject * obj0 = 0 ;
4296 char *kwnames[] = {
4297 (char *) "self", NULL
4298 };
4299
4300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetHandle",kwnames,&obj0)) goto fail;
4301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4302 if (SWIG_arg_fail(1)) SWIG_fail;
4303 {
4304 PyThreadState* __tstate = wxPyBeginAllowThreads();
4305 result = (long)(arg1)->GetHandle();
4306
4307 wxPyEndAllowThreads(__tstate);
4308 if (PyErr_Occurred()) SWIG_fail;
4309 }
4310 {
4311 resultobj = SWIG_From_long((long)(result));
4312 }
4313 return resultobj;
4314 fail:
4315 return NULL;
4316 }
4317
4318
4319 static PyObject *_wrap_Bitmap_SetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
4320 PyObject *resultobj;
4321 wxBitmap *arg1 = (wxBitmap *) 0 ;
4322 long arg2 ;
4323 PyObject * obj0 = 0 ;
4324 PyObject * obj1 = 0 ;
4325 char *kwnames[] = {
4326 (char *) "self",(char *) "handle", NULL
4327 };
4328
4329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHandle",kwnames,&obj0,&obj1)) goto fail;
4330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4331 if (SWIG_arg_fail(1)) SWIG_fail;
4332 {
4333 arg2 = (long)(SWIG_As_long(obj1));
4334 if (SWIG_arg_fail(2)) SWIG_fail;
4335 }
4336 {
4337 PyThreadState* __tstate = wxPyBeginAllowThreads();
4338 wxBitmap_SetHandle(arg1,arg2);
4339
4340 wxPyEndAllowThreads(__tstate);
4341 if (PyErr_Occurred()) SWIG_fail;
4342 }
4343 Py_INCREF(Py_None); resultobj = Py_None;
4344 return resultobj;
4345 fail:
4346 return NULL;
4347 }
4348
4349
4350 static PyObject *_wrap_Bitmap_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
4351 PyObject *resultobj;
4352 wxBitmap *arg1 = (wxBitmap *) 0 ;
4353 bool result;
4354 PyObject * obj0 = 0 ;
4355 char *kwnames[] = {
4356 (char *) "self", NULL
4357 };
4358
4359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_Ok",kwnames,&obj0)) goto fail;
4360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4361 if (SWIG_arg_fail(1)) SWIG_fail;
4362 {
4363 PyThreadState* __tstate = wxPyBeginAllowThreads();
4364 result = (bool)(arg1)->Ok();
4365
4366 wxPyEndAllowThreads(__tstate);
4367 if (PyErr_Occurred()) SWIG_fail;
4368 }
4369 {
4370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4371 }
4372 return resultobj;
4373 fail:
4374 return NULL;
4375 }
4376
4377
4378 static PyObject *_wrap_Bitmap_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4379 PyObject *resultobj;
4380 wxBitmap *arg1 = (wxBitmap *) 0 ;
4381 int result;
4382 PyObject * obj0 = 0 ;
4383 char *kwnames[] = {
4384 (char *) "self", NULL
4385 };
4386
4387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetWidth",kwnames,&obj0)) goto fail;
4388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4389 if (SWIG_arg_fail(1)) SWIG_fail;
4390 {
4391 PyThreadState* __tstate = wxPyBeginAllowThreads();
4392 result = (int)(arg1)->GetWidth();
4393
4394 wxPyEndAllowThreads(__tstate);
4395 if (PyErr_Occurred()) SWIG_fail;
4396 }
4397 {
4398 resultobj = SWIG_From_int((int)(result));
4399 }
4400 return resultobj;
4401 fail:
4402 return NULL;
4403 }
4404
4405
4406 static PyObject *_wrap_Bitmap_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4407 PyObject *resultobj;
4408 wxBitmap *arg1 = (wxBitmap *) 0 ;
4409 int result;
4410 PyObject * obj0 = 0 ;
4411 char *kwnames[] = {
4412 (char *) "self", NULL
4413 };
4414
4415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetHeight",kwnames,&obj0)) goto fail;
4416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4417 if (SWIG_arg_fail(1)) SWIG_fail;
4418 {
4419 PyThreadState* __tstate = wxPyBeginAllowThreads();
4420 result = (int)(arg1)->GetHeight();
4421
4422 wxPyEndAllowThreads(__tstate);
4423 if (PyErr_Occurred()) SWIG_fail;
4424 }
4425 {
4426 resultobj = SWIG_From_int((int)(result));
4427 }
4428 return resultobj;
4429 fail:
4430 return NULL;
4431 }
4432
4433
4434 static PyObject *_wrap_Bitmap_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4435 PyObject *resultobj;
4436 wxBitmap *arg1 = (wxBitmap *) 0 ;
4437 int result;
4438 PyObject * obj0 = 0 ;
4439 char *kwnames[] = {
4440 (char *) "self", NULL
4441 };
4442
4443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetDepth",kwnames,&obj0)) goto fail;
4444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4445 if (SWIG_arg_fail(1)) SWIG_fail;
4446 {
4447 PyThreadState* __tstate = wxPyBeginAllowThreads();
4448 result = (int)(arg1)->GetDepth();
4449
4450 wxPyEndAllowThreads(__tstate);
4451 if (PyErr_Occurred()) SWIG_fail;
4452 }
4453 {
4454 resultobj = SWIG_From_int((int)(result));
4455 }
4456 return resultobj;
4457 fail:
4458 return NULL;
4459 }
4460
4461
4462 static PyObject *_wrap_Bitmap_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4463 PyObject *resultobj;
4464 wxBitmap *arg1 = (wxBitmap *) 0 ;
4465 wxSize result;
4466 PyObject * obj0 = 0 ;
4467 char *kwnames[] = {
4468 (char *) "self", NULL
4469 };
4470
4471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetSize",kwnames,&obj0)) goto fail;
4472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4473 if (SWIG_arg_fail(1)) SWIG_fail;
4474 {
4475 PyThreadState* __tstate = wxPyBeginAllowThreads();
4476 result = wxBitmap_GetSize(arg1);
4477
4478 wxPyEndAllowThreads(__tstate);
4479 if (PyErr_Occurred()) SWIG_fail;
4480 }
4481 {
4482 wxSize * resultptr;
4483 resultptr = new wxSize((wxSize &)(result));
4484 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
4485 }
4486 return resultobj;
4487 fail:
4488 return NULL;
4489 }
4490
4491
4492 static PyObject *_wrap_Bitmap_ConvertToImage(PyObject *, PyObject *args, PyObject *kwargs) {
4493 PyObject *resultobj;
4494 wxBitmap *arg1 = (wxBitmap *) 0 ;
4495 SwigValueWrapper<wxImage > result;
4496 PyObject * obj0 = 0 ;
4497 char *kwnames[] = {
4498 (char *) "self", NULL
4499 };
4500
4501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_ConvertToImage",kwnames,&obj0)) goto fail;
4502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4503 if (SWIG_arg_fail(1)) SWIG_fail;
4504 {
4505 PyThreadState* __tstate = wxPyBeginAllowThreads();
4506 result = ((wxBitmap const *)arg1)->ConvertToImage();
4507
4508 wxPyEndAllowThreads(__tstate);
4509 if (PyErr_Occurred()) SWIG_fail;
4510 }
4511 {
4512 wxImage * resultptr;
4513 resultptr = new wxImage((wxImage &)(result));
4514 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
4515 }
4516 return resultobj;
4517 fail:
4518 return NULL;
4519 }
4520
4521
4522 static PyObject *_wrap_Bitmap_GetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4523 PyObject *resultobj;
4524 wxBitmap *arg1 = (wxBitmap *) 0 ;
4525 wxMask *result;
4526 PyObject * obj0 = 0 ;
4527 char *kwnames[] = {
4528 (char *) "self", NULL
4529 };
4530
4531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetMask",kwnames,&obj0)) goto fail;
4532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4533 if (SWIG_arg_fail(1)) SWIG_fail;
4534 {
4535 PyThreadState* __tstate = wxPyBeginAllowThreads();
4536 result = (wxMask *)((wxBitmap const *)arg1)->GetMask();
4537
4538 wxPyEndAllowThreads(__tstate);
4539 if (PyErr_Occurred()) SWIG_fail;
4540 }
4541 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 0);
4542 return resultobj;
4543 fail:
4544 return NULL;
4545 }
4546
4547
4548 static PyObject *_wrap_Bitmap_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4549 PyObject *resultobj;
4550 wxBitmap *arg1 = (wxBitmap *) 0 ;
4551 wxMask *arg2 = (wxMask *) 0 ;
4552 PyObject * obj0 = 0 ;
4553 PyObject * obj1 = 0 ;
4554 char *kwnames[] = {
4555 (char *) "self",(char *) "mask", NULL
4556 };
4557
4558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMask",kwnames,&obj0,&obj1)) goto fail;
4559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4560 if (SWIG_arg_fail(1)) SWIG_fail;
4561 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMask, SWIG_POINTER_EXCEPTION | 0);
4562 if (SWIG_arg_fail(2)) SWIG_fail;
4563 {
4564 PyThreadState* __tstate = wxPyBeginAllowThreads();
4565 (arg1)->SetMask(arg2);
4566
4567 wxPyEndAllowThreads(__tstate);
4568 if (PyErr_Occurred()) SWIG_fail;
4569 }
4570 Py_INCREF(Py_None); resultobj = Py_None;
4571 return resultobj;
4572 fail:
4573 return NULL;
4574 }
4575
4576
4577 static PyObject *_wrap_Bitmap_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
4578 PyObject *resultobj;
4579 wxBitmap *arg1 = (wxBitmap *) 0 ;
4580 wxColour *arg2 = 0 ;
4581 wxColour temp2 ;
4582 PyObject * obj0 = 0 ;
4583 PyObject * obj1 = 0 ;
4584 char *kwnames[] = {
4585 (char *) "self",(char *) "colour", NULL
4586 };
4587
4588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMaskColour",kwnames,&obj0,&obj1)) goto fail;
4589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4590 if (SWIG_arg_fail(1)) SWIG_fail;
4591 {
4592 arg2 = &temp2;
4593 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4594 }
4595 {
4596 PyThreadState* __tstate = wxPyBeginAllowThreads();
4597 wxBitmap_SetMaskColour(arg1,(wxColour const &)*arg2);
4598
4599 wxPyEndAllowThreads(__tstate);
4600 if (PyErr_Occurred()) SWIG_fail;
4601 }
4602 Py_INCREF(Py_None); resultobj = Py_None;
4603 return resultobj;
4604 fail:
4605 return NULL;
4606 }
4607
4608
4609 static PyObject *_wrap_Bitmap_GetSubBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4610 PyObject *resultobj;
4611 wxBitmap *arg1 = (wxBitmap *) 0 ;
4612 wxRect *arg2 = 0 ;
4613 SwigValueWrapper<wxBitmap > result;
4614 wxRect temp2 ;
4615 PyObject * obj0 = 0 ;
4616 PyObject * obj1 = 0 ;
4617 char *kwnames[] = {
4618 (char *) "self",(char *) "rect", NULL
4619 };
4620
4621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_GetSubBitmap",kwnames,&obj0,&obj1)) goto fail;
4622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4623 if (SWIG_arg_fail(1)) SWIG_fail;
4624 {
4625 arg2 = &temp2;
4626 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4627 }
4628 {
4629 PyThreadState* __tstate = wxPyBeginAllowThreads();
4630 result = ((wxBitmap const *)arg1)->GetSubBitmap((wxRect const &)*arg2);
4631
4632 wxPyEndAllowThreads(__tstate);
4633 if (PyErr_Occurred()) SWIG_fail;
4634 }
4635 {
4636 wxBitmap * resultptr;
4637 resultptr = new wxBitmap((wxBitmap &)(result));
4638 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
4639 }
4640 return resultobj;
4641 fail:
4642 return NULL;
4643 }
4644
4645
4646 static PyObject *_wrap_Bitmap_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
4647 PyObject *resultobj;
4648 wxBitmap *arg1 = (wxBitmap *) 0 ;
4649 wxString *arg2 = 0 ;
4650 wxBitmapType arg3 ;
4651 wxPalette *arg4 = (wxPalette *) NULL ;
4652 bool result;
4653 bool temp2 = false ;
4654 PyObject * obj0 = 0 ;
4655 PyObject * obj1 = 0 ;
4656 PyObject * obj2 = 0 ;
4657 PyObject * obj3 = 0 ;
4658 char *kwnames[] = {
4659 (char *) "self",(char *) "name",(char *) "type",(char *) "palette", NULL
4660 };
4661
4662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Bitmap_SaveFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4664 if (SWIG_arg_fail(1)) SWIG_fail;
4665 {
4666 arg2 = wxString_in_helper(obj1);
4667 if (arg2 == NULL) SWIG_fail;
4668 temp2 = true;
4669 }
4670 {
4671 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4672 if (SWIG_arg_fail(3)) SWIG_fail;
4673 }
4674 if (obj3) {
4675 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
4676 if (SWIG_arg_fail(4)) SWIG_fail;
4677 }
4678 {
4679 PyThreadState* __tstate = wxPyBeginAllowThreads();
4680 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxBitmapType )arg3,arg4);
4681
4682 wxPyEndAllowThreads(__tstate);
4683 if (PyErr_Occurred()) SWIG_fail;
4684 }
4685 {
4686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4687 }
4688 {
4689 if (temp2)
4690 delete arg2;
4691 }
4692 return resultobj;
4693 fail:
4694 {
4695 if (temp2)
4696 delete arg2;
4697 }
4698 return NULL;
4699 }
4700
4701
4702 static PyObject *_wrap_Bitmap_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
4703 PyObject *resultobj;
4704 wxBitmap *arg1 = (wxBitmap *) 0 ;
4705 wxString *arg2 = 0 ;
4706 wxBitmapType arg3 ;
4707 bool result;
4708 bool temp2 = false ;
4709 PyObject * obj0 = 0 ;
4710 PyObject * obj1 = 0 ;
4711 PyObject * obj2 = 0 ;
4712 char *kwnames[] = {
4713 (char *) "self",(char *) "name",(char *) "type", NULL
4714 };
4715
4716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Bitmap_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
4717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4718 if (SWIG_arg_fail(1)) SWIG_fail;
4719 {
4720 arg2 = wxString_in_helper(obj1);
4721 if (arg2 == NULL) SWIG_fail;
4722 temp2 = true;
4723 }
4724 {
4725 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4726 if (SWIG_arg_fail(3)) SWIG_fail;
4727 }
4728 {
4729 PyThreadState* __tstate = wxPyBeginAllowThreads();
4730 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
4731
4732 wxPyEndAllowThreads(__tstate);
4733 if (PyErr_Occurred()) SWIG_fail;
4734 }
4735 {
4736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4737 }
4738 {
4739 if (temp2)
4740 delete arg2;
4741 }
4742 return resultobj;
4743 fail:
4744 {
4745 if (temp2)
4746 delete arg2;
4747 }
4748 return NULL;
4749 }
4750
4751
4752 static PyObject *_wrap_Bitmap_GetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
4753 PyObject *resultobj;
4754 wxBitmap *arg1 = (wxBitmap *) 0 ;
4755 wxPalette *result;
4756 PyObject * obj0 = 0 ;
4757 char *kwnames[] = {
4758 (char *) "self", NULL
4759 };
4760
4761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetPalette",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
4766 result = (wxPalette *)((wxBitmap const *)arg1)->GetPalette();
4767
4768 wxPyEndAllowThreads(__tstate);
4769 if (PyErr_Occurred()) SWIG_fail;
4770 }
4771 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 0);
4772 return resultobj;
4773 fail:
4774 return NULL;
4775 }
4776
4777
4778 static PyObject *_wrap_Bitmap_SetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
4779 PyObject *resultobj;
4780 wxBitmap *arg1 = (wxBitmap *) 0 ;
4781 wxPalette *arg2 = 0 ;
4782 PyObject * obj0 = 0 ;
4783 PyObject * obj1 = 0 ;
4784 char *kwnames[] = {
4785 (char *) "self",(char *) "palette", NULL
4786 };
4787
4788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetPalette",kwnames,&obj0,&obj1)) goto fail;
4789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4790 if (SWIG_arg_fail(1)) SWIG_fail;
4791 {
4792 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
4793 if (SWIG_arg_fail(2)) SWIG_fail;
4794 if (arg2 == NULL) {
4795 SWIG_null_ref("wxPalette");
4796 }
4797 if (SWIG_arg_fail(2)) SWIG_fail;
4798 }
4799 {
4800 PyThreadState* __tstate = wxPyBeginAllowThreads();
4801 (arg1)->SetPalette((wxPalette const &)*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_CopyFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4814 PyObject *resultobj;
4815 wxBitmap *arg1 = (wxBitmap *) 0 ;
4816 wxIcon *arg2 = 0 ;
4817 bool result;
4818 PyObject * obj0 = 0 ;
4819 PyObject * obj1 = 0 ;
4820 char *kwnames[] = {
4821 (char *) "self",(char *) "icon", NULL
4822 };
4823
4824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromIcon",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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4829 if (SWIG_arg_fail(2)) SWIG_fail;
4830 if (arg2 == NULL) {
4831 SWIG_null_ref("wxIcon");
4832 }
4833 if (SWIG_arg_fail(2)) SWIG_fail;
4834 }
4835 {
4836 PyThreadState* __tstate = wxPyBeginAllowThreads();
4837 result = (bool)(arg1)->CopyFromIcon((wxIcon const &)*arg2);
4838
4839 wxPyEndAllowThreads(__tstate);
4840 if (PyErr_Occurred()) SWIG_fail;
4841 }
4842 {
4843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4844 }
4845 return resultobj;
4846 fail:
4847 return NULL;
4848 }
4849
4850
4851 static PyObject *_wrap_Bitmap_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4852 PyObject *resultobj;
4853 wxBitmap *arg1 = (wxBitmap *) 0 ;
4854 int arg2 ;
4855 PyObject * obj0 = 0 ;
4856 PyObject * obj1 = 0 ;
4857 char *kwnames[] = {
4858 (char *) "self",(char *) "height", NULL
4859 };
4860
4861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHeight",kwnames,&obj0,&obj1)) goto fail;
4862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4863 if (SWIG_arg_fail(1)) SWIG_fail;
4864 {
4865 arg2 = (int)(SWIG_As_int(obj1));
4866 if (SWIG_arg_fail(2)) SWIG_fail;
4867 }
4868 {
4869 PyThreadState* __tstate = wxPyBeginAllowThreads();
4870 (arg1)->SetHeight(arg2);
4871
4872 wxPyEndAllowThreads(__tstate);
4873 if (PyErr_Occurred()) SWIG_fail;
4874 }
4875 Py_INCREF(Py_None); resultobj = Py_None;
4876 return resultobj;
4877 fail:
4878 return NULL;
4879 }
4880
4881
4882 static PyObject *_wrap_Bitmap_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4883 PyObject *resultobj;
4884 wxBitmap *arg1 = (wxBitmap *) 0 ;
4885 int arg2 ;
4886 PyObject * obj0 = 0 ;
4887 PyObject * obj1 = 0 ;
4888 char *kwnames[] = {
4889 (char *) "self",(char *) "width", NULL
4890 };
4891
4892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetWidth",kwnames,&obj0,&obj1)) goto fail;
4893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4894 if (SWIG_arg_fail(1)) SWIG_fail;
4895 {
4896 arg2 = (int)(SWIG_As_int(obj1));
4897 if (SWIG_arg_fail(2)) SWIG_fail;
4898 }
4899 {
4900 PyThreadState* __tstate = wxPyBeginAllowThreads();
4901 (arg1)->SetWidth(arg2);
4902
4903 wxPyEndAllowThreads(__tstate);
4904 if (PyErr_Occurred()) SWIG_fail;
4905 }
4906 Py_INCREF(Py_None); resultobj = Py_None;
4907 return resultobj;
4908 fail:
4909 return NULL;
4910 }
4911
4912
4913 static PyObject *_wrap_Bitmap_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4914 PyObject *resultobj;
4915 wxBitmap *arg1 = (wxBitmap *) 0 ;
4916 int arg2 ;
4917 PyObject * obj0 = 0 ;
4918 PyObject * obj1 = 0 ;
4919 char *kwnames[] = {
4920 (char *) "self",(char *) "depth", NULL
4921 };
4922
4923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetDepth",kwnames,&obj0,&obj1)) goto fail;
4924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4925 if (SWIG_arg_fail(1)) SWIG_fail;
4926 {
4927 arg2 = (int)(SWIG_As_int(obj1));
4928 if (SWIG_arg_fail(2)) SWIG_fail;
4929 }
4930 {
4931 PyThreadState* __tstate = wxPyBeginAllowThreads();
4932 (arg1)->SetDepth(arg2);
4933
4934 wxPyEndAllowThreads(__tstate);
4935 if (PyErr_Occurred()) SWIG_fail;
4936 }
4937 Py_INCREF(Py_None); resultobj = Py_None;
4938 return resultobj;
4939 fail:
4940 return NULL;
4941 }
4942
4943
4944 static PyObject *_wrap_Bitmap_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4945 PyObject *resultobj;
4946 wxBitmap *arg1 = (wxBitmap *) 0 ;
4947 wxSize *arg2 = 0 ;
4948 wxSize temp2 ;
4949 PyObject * obj0 = 0 ;
4950 PyObject * obj1 = 0 ;
4951 char *kwnames[] = {
4952 (char *) "self",(char *) "size", NULL
4953 };
4954
4955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetSize",kwnames,&obj0,&obj1)) goto fail;
4956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4957 if (SWIG_arg_fail(1)) SWIG_fail;
4958 {
4959 arg2 = &temp2;
4960 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4961 }
4962 {
4963 PyThreadState* __tstate = wxPyBeginAllowThreads();
4964 wxBitmap_SetSize(arg1,(wxSize const &)*arg2);
4965
4966 wxPyEndAllowThreads(__tstate);
4967 if (PyErr_Occurred()) SWIG_fail;
4968 }
4969 Py_INCREF(Py_None); resultobj = Py_None;
4970 return resultobj;
4971 fail:
4972 return NULL;
4973 }
4974
4975
4976 static PyObject *_wrap_Bitmap_CopyFromCursor(PyObject *, PyObject *args, PyObject *kwargs) {
4977 PyObject *resultobj;
4978 wxBitmap *arg1 = (wxBitmap *) 0 ;
4979 wxCursor *arg2 = 0 ;
4980 bool result;
4981 PyObject * obj0 = 0 ;
4982 PyObject * obj1 = 0 ;
4983 char *kwnames[] = {
4984 (char *) "self",(char *) "cursor", NULL
4985 };
4986
4987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromCursor",kwnames,&obj0,&obj1)) goto fail;
4988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4989 if (SWIG_arg_fail(1)) SWIG_fail;
4990 {
4991 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
4992 if (SWIG_arg_fail(2)) SWIG_fail;
4993 if (arg2 == NULL) {
4994 SWIG_null_ref("wxCursor");
4995 }
4996 if (SWIG_arg_fail(2)) SWIG_fail;
4997 }
4998 {
4999 PyThreadState* __tstate = wxPyBeginAllowThreads();
5000 result = (bool)(arg1)->CopyFromCursor((wxCursor const &)*arg2);
5001
5002 wxPyEndAllowThreads(__tstate);
5003 if (PyErr_Occurred()) SWIG_fail;
5004 }
5005 {
5006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5007 }
5008 return resultobj;
5009 fail:
5010 return NULL;
5011 }
5012
5013
5014 static PyObject *_wrap_Bitmap___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5015 PyObject *resultobj;
5016 wxBitmap *arg1 = (wxBitmap *) 0 ;
5017 wxBitmap *arg2 = (wxBitmap *) 0 ;
5018 bool result;
5019 PyObject * obj0 = 0 ;
5020 PyObject * obj1 = 0 ;
5021 char *kwnames[] = {
5022 (char *) "self",(char *) "other", NULL
5023 };
5024
5025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___eq__",kwnames,&obj0,&obj1)) goto fail;
5026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5027 if (SWIG_arg_fail(1)) SWIG_fail;
5028 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5029 if (SWIG_arg_fail(2)) SWIG_fail;
5030 {
5031 PyThreadState* __tstate = wxPyBeginAllowThreads();
5032 result = (bool)wxBitmap___eq__(arg1,(wxBitmap const *)arg2);
5033
5034 wxPyEndAllowThreads(__tstate);
5035 if (PyErr_Occurred()) SWIG_fail;
5036 }
5037 {
5038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5039 }
5040 return resultobj;
5041 fail:
5042 return NULL;
5043 }
5044
5045
5046 static PyObject *_wrap_Bitmap___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
5047 PyObject *resultobj;
5048 wxBitmap *arg1 = (wxBitmap *) 0 ;
5049 wxBitmap *arg2 = (wxBitmap *) 0 ;
5050 bool result;
5051 PyObject * obj0 = 0 ;
5052 PyObject * obj1 = 0 ;
5053 char *kwnames[] = {
5054 (char *) "self",(char *) "other", NULL
5055 };
5056
5057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___ne__",kwnames,&obj0,&obj1)) goto fail;
5058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5059 if (SWIG_arg_fail(1)) SWIG_fail;
5060 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5061 if (SWIG_arg_fail(2)) SWIG_fail;
5062 {
5063 PyThreadState* __tstate = wxPyBeginAllowThreads();
5064 result = (bool)wxBitmap___ne__(arg1,(wxBitmap const *)arg2);
5065
5066 wxPyEndAllowThreads(__tstate);
5067 if (PyErr_Occurred()) SWIG_fail;
5068 }
5069 {
5070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5071 }
5072 return resultobj;
5073 fail:
5074 return NULL;
5075 }
5076
5077
5078 static PyObject * Bitmap_swigregister(PyObject *, PyObject *args) {
5079 PyObject *obj;
5080 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5081 SWIG_TypeClientData(SWIGTYPE_p_wxBitmap, obj);
5082 Py_INCREF(obj);
5083 return Py_BuildValue((char *)"");
5084 }
5085 static PyObject *_wrap_new_Mask(PyObject *, PyObject *args, PyObject *kwargs) {
5086 PyObject *resultobj;
5087 wxBitmap *arg1 = 0 ;
5088 wxColour const &arg2_defvalue = wxNullColour ;
5089 wxColour *arg2 = (wxColour *) &arg2_defvalue ;
5090 wxMask *result;
5091 wxColour temp2 ;
5092 PyObject * obj0 = 0 ;
5093 PyObject * obj1 = 0 ;
5094 char *kwnames[] = {
5095 (char *) "bitmap",(char *) "colour", NULL
5096 };
5097
5098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Mask",kwnames,&obj0,&obj1)) goto fail;
5099 {
5100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5101 if (SWIG_arg_fail(1)) SWIG_fail;
5102 if (arg1 == NULL) {
5103 SWIG_null_ref("wxBitmap");
5104 }
5105 if (SWIG_arg_fail(1)) SWIG_fail;
5106 }
5107 if (obj1) {
5108 {
5109 arg2 = &temp2;
5110 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5111 }
5112 }
5113 {
5114 if (!wxPyCheckForApp()) SWIG_fail;
5115 PyThreadState* __tstate = wxPyBeginAllowThreads();
5116 result = (wxMask *)new_wxMask((wxBitmap const &)*arg1,(wxColour const &)*arg2);
5117
5118 wxPyEndAllowThreads(__tstate);
5119 if (PyErr_Occurred()) SWIG_fail;
5120 }
5121 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 1);
5122 return resultobj;
5123 fail:
5124 return NULL;
5125 }
5126
5127
5128 static PyObject * Mask_swigregister(PyObject *, PyObject *args) {
5129 PyObject *obj;
5130 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5131 SWIG_TypeClientData(SWIGTYPE_p_wxMask, obj);
5132 Py_INCREF(obj);
5133 return Py_BuildValue((char *)"");
5134 }
5135 static PyObject *_wrap_new_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
5136 PyObject *resultobj;
5137 wxString *arg1 = 0 ;
5138 wxBitmapType arg2 ;
5139 int arg3 = (int) -1 ;
5140 int arg4 = (int) -1 ;
5141 wxIcon *result;
5142 bool temp1 = false ;
5143 PyObject * obj0 = 0 ;
5144 PyObject * obj1 = 0 ;
5145 PyObject * obj2 = 0 ;
5146 PyObject * obj3 = 0 ;
5147 char *kwnames[] = {
5148 (char *) "name",(char *) "type",(char *) "desiredWidth",(char *) "desiredHeight", NULL
5149 };
5150
5151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Icon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5152 {
5153 arg1 = wxString_in_helper(obj0);
5154 if (arg1 == NULL) SWIG_fail;
5155 temp1 = true;
5156 }
5157 {
5158 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
5159 if (SWIG_arg_fail(2)) SWIG_fail;
5160 }
5161 if (obj2) {
5162 {
5163 arg3 = (int)(SWIG_As_int(obj2));
5164 if (SWIG_arg_fail(3)) SWIG_fail;
5165 }
5166 }
5167 if (obj3) {
5168 {
5169 arg4 = (int)(SWIG_As_int(obj3));
5170 if (SWIG_arg_fail(4)) SWIG_fail;
5171 }
5172 }
5173 {
5174 if (!wxPyCheckForApp()) SWIG_fail;
5175 PyThreadState* __tstate = wxPyBeginAllowThreads();
5176 result = (wxIcon *)new wxIcon((wxString const &)*arg1,(wxBitmapType )arg2,arg3,arg4);
5177
5178 wxPyEndAllowThreads(__tstate);
5179 if (PyErr_Occurred()) SWIG_fail;
5180 }
5181 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5182 {
5183 if (temp1)
5184 delete arg1;
5185 }
5186 return resultobj;
5187 fail:
5188 {
5189 if (temp1)
5190 delete arg1;
5191 }
5192 return NULL;
5193 }
5194
5195
5196 static PyObject *_wrap_delete_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
5197 PyObject *resultobj;
5198 wxIcon *arg1 = (wxIcon *) 0 ;
5199 PyObject * obj0 = 0 ;
5200 char *kwnames[] = {
5201 (char *) "self", NULL
5202 };
5203
5204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Icon",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 delete arg1;
5210
5211 wxPyEndAllowThreads(__tstate);
5212 if (PyErr_Occurred()) SWIG_fail;
5213 }
5214 Py_INCREF(Py_None); resultobj = Py_None;
5215 return resultobj;
5216 fail:
5217 return NULL;
5218 }
5219
5220
5221 static PyObject *_wrap_new_EmptyIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5222 PyObject *resultobj;
5223 wxIcon *result;
5224 char *kwnames[] = {
5225 NULL
5226 };
5227
5228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EmptyIcon",kwnames)) goto fail;
5229 {
5230 if (!wxPyCheckForApp()) SWIG_fail;
5231 PyThreadState* __tstate = wxPyBeginAllowThreads();
5232 result = (wxIcon *)new wxIcon();
5233
5234 wxPyEndAllowThreads(__tstate);
5235 if (PyErr_Occurred()) SWIG_fail;
5236 }
5237 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5238 return resultobj;
5239 fail:
5240 return NULL;
5241 }
5242
5243
5244 static PyObject *_wrap_new_IconFromLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5245 PyObject *resultobj;
5246 wxIconLocation *arg1 = 0 ;
5247 wxIcon *result;
5248 PyObject * obj0 = 0 ;
5249 char *kwnames[] = {
5250 (char *) "loc", NULL
5251 };
5252
5253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromLocation",kwnames,&obj0)) goto fail;
5254 {
5255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5256 if (SWIG_arg_fail(1)) SWIG_fail;
5257 if (arg1 == NULL) {
5258 SWIG_null_ref("wxIconLocation");
5259 }
5260 if (SWIG_arg_fail(1)) SWIG_fail;
5261 }
5262 {
5263 if (!wxPyCheckForApp()) SWIG_fail;
5264 PyThreadState* __tstate = wxPyBeginAllowThreads();
5265 result = (wxIcon *)new wxIcon((wxIconLocation const &)*arg1);
5266
5267 wxPyEndAllowThreads(__tstate);
5268 if (PyErr_Occurred()) SWIG_fail;
5269 }
5270 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5271 return resultobj;
5272 fail:
5273 return NULL;
5274 }
5275
5276
5277 static PyObject *_wrap_new_IconFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5278 PyObject *resultobj;
5279 wxBitmap *arg1 = 0 ;
5280 wxIcon *result;
5281 PyObject * obj0 = 0 ;
5282 char *kwnames[] = {
5283 (char *) "bmp", NULL
5284 };
5285
5286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromBitmap",kwnames,&obj0)) goto fail;
5287 {
5288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5289 if (SWIG_arg_fail(1)) SWIG_fail;
5290 if (arg1 == NULL) {
5291 SWIG_null_ref("wxBitmap");
5292 }
5293 if (SWIG_arg_fail(1)) SWIG_fail;
5294 }
5295 {
5296 if (!wxPyCheckForApp()) SWIG_fail;
5297 PyThreadState* __tstate = wxPyBeginAllowThreads();
5298 result = (wxIcon *)new_wxIcon((wxBitmap const &)*arg1);
5299
5300 wxPyEndAllowThreads(__tstate);
5301 if (PyErr_Occurred()) SWIG_fail;
5302 }
5303 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5304 return resultobj;
5305 fail:
5306 return NULL;
5307 }
5308
5309
5310 static PyObject *_wrap_new_IconFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
5311 PyObject *resultobj;
5312 PyObject *arg1 = (PyObject *) 0 ;
5313 wxIcon *result;
5314 PyObject * obj0 = 0 ;
5315 char *kwnames[] = {
5316 (char *) "listOfStrings", NULL
5317 };
5318
5319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromXPMData",kwnames,&obj0)) goto fail;
5320 arg1 = obj0;
5321 {
5322 if (!wxPyCheckForApp()) SWIG_fail;
5323 PyThreadState* __tstate = wxPyBeginAllowThreads();
5324 result = (wxIcon *)new_wxIcon(arg1);
5325
5326 wxPyEndAllowThreads(__tstate);
5327 if (PyErr_Occurred()) SWIG_fail;
5328 }
5329 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5330 return resultobj;
5331 fail:
5332 return NULL;
5333 }
5334
5335
5336 static PyObject *_wrap_Icon_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
5337 PyObject *resultobj;
5338 wxIcon *arg1 = (wxIcon *) 0 ;
5339 wxString *arg2 = 0 ;
5340 wxBitmapType arg3 ;
5341 bool result;
5342 bool temp2 = false ;
5343 PyObject * obj0 = 0 ;
5344 PyObject * obj1 = 0 ;
5345 PyObject * obj2 = 0 ;
5346 char *kwnames[] = {
5347 (char *) "self",(char *) "name",(char *) "type", NULL
5348 };
5349
5350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Icon_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
5351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5352 if (SWIG_arg_fail(1)) SWIG_fail;
5353 {
5354 arg2 = wxString_in_helper(obj1);
5355 if (arg2 == NULL) SWIG_fail;
5356 temp2 = true;
5357 }
5358 {
5359 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
5360 if (SWIG_arg_fail(3)) SWIG_fail;
5361 }
5362 {
5363 PyThreadState* __tstate = wxPyBeginAllowThreads();
5364 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
5365
5366 wxPyEndAllowThreads(__tstate);
5367 if (PyErr_Occurred()) SWIG_fail;
5368 }
5369 {
5370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5371 }
5372 {
5373 if (temp2)
5374 delete arg2;
5375 }
5376 return resultobj;
5377 fail:
5378 {
5379 if (temp2)
5380 delete arg2;
5381 }
5382 return NULL;
5383 }
5384
5385
5386 static PyObject *_wrap_Icon_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
5387 PyObject *resultobj;
5388 wxIcon *arg1 = (wxIcon *) 0 ;
5389 long result;
5390 PyObject * obj0 = 0 ;
5391 char *kwnames[] = {
5392 (char *) "self", NULL
5393 };
5394
5395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetHandle",kwnames,&obj0)) goto fail;
5396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5397 if (SWIG_arg_fail(1)) SWIG_fail;
5398 {
5399 PyThreadState* __tstate = wxPyBeginAllowThreads();
5400 result = (long)(arg1)->GetHandle();
5401
5402 wxPyEndAllowThreads(__tstate);
5403 if (PyErr_Occurred()) SWIG_fail;
5404 }
5405 {
5406 resultobj = SWIG_From_long((long)(result));
5407 }
5408 return resultobj;
5409 fail:
5410 return NULL;
5411 }
5412
5413
5414 static PyObject *_wrap_Icon_SetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
5415 PyObject *resultobj;
5416 wxIcon *arg1 = (wxIcon *) 0 ;
5417 long arg2 ;
5418 PyObject * obj0 = 0 ;
5419 PyObject * obj1 = 0 ;
5420 char *kwnames[] = {
5421 (char *) "self",(char *) "handle", NULL
5422 };
5423
5424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHandle",kwnames,&obj0,&obj1)) goto fail;
5425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5426 if (SWIG_arg_fail(1)) SWIG_fail;
5427 {
5428 arg2 = (long)(SWIG_As_long(obj1));
5429 if (SWIG_arg_fail(2)) SWIG_fail;
5430 }
5431 {
5432 PyThreadState* __tstate = wxPyBeginAllowThreads();
5433 wxIcon_SetHandle(arg1,arg2);
5434
5435 wxPyEndAllowThreads(__tstate);
5436 if (PyErr_Occurred()) SWIG_fail;
5437 }
5438 Py_INCREF(Py_None); resultobj = Py_None;
5439 return resultobj;
5440 fail:
5441 return NULL;
5442 }
5443
5444
5445 static PyObject *_wrap_Icon_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
5446 PyObject *resultobj;
5447 wxIcon *arg1 = (wxIcon *) 0 ;
5448 bool result;
5449 PyObject * obj0 = 0 ;
5450 char *kwnames[] = {
5451 (char *) "self", NULL
5452 };
5453
5454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_Ok",kwnames,&obj0)) goto fail;
5455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5456 if (SWIG_arg_fail(1)) SWIG_fail;
5457 {
5458 PyThreadState* __tstate = wxPyBeginAllowThreads();
5459 result = (bool)(arg1)->Ok();
5460
5461 wxPyEndAllowThreads(__tstate);
5462 if (PyErr_Occurred()) SWIG_fail;
5463 }
5464 {
5465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5466 }
5467 return resultobj;
5468 fail:
5469 return NULL;
5470 }
5471
5472
5473 static PyObject *_wrap_Icon_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5474 PyObject *resultobj;
5475 wxIcon *arg1 = (wxIcon *) 0 ;
5476 int result;
5477 PyObject * obj0 = 0 ;
5478 char *kwnames[] = {
5479 (char *) "self", NULL
5480 };
5481
5482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetWidth",kwnames,&obj0)) goto fail;
5483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5484 if (SWIG_arg_fail(1)) SWIG_fail;
5485 {
5486 PyThreadState* __tstate = wxPyBeginAllowThreads();
5487 result = (int)(arg1)->GetWidth();
5488
5489 wxPyEndAllowThreads(__tstate);
5490 if (PyErr_Occurred()) SWIG_fail;
5491 }
5492 {
5493 resultobj = SWIG_From_int((int)(result));
5494 }
5495 return resultobj;
5496 fail:
5497 return NULL;
5498 }
5499
5500
5501 static PyObject *_wrap_Icon_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5502 PyObject *resultobj;
5503 wxIcon *arg1 = (wxIcon *) 0 ;
5504 int result;
5505 PyObject * obj0 = 0 ;
5506 char *kwnames[] = {
5507 (char *) "self", NULL
5508 };
5509
5510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetHeight",kwnames,&obj0)) goto fail;
5511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5512 if (SWIG_arg_fail(1)) SWIG_fail;
5513 {
5514 PyThreadState* __tstate = wxPyBeginAllowThreads();
5515 result = (int)(arg1)->GetHeight();
5516
5517 wxPyEndAllowThreads(__tstate);
5518 if (PyErr_Occurred()) SWIG_fail;
5519 }
5520 {
5521 resultobj = SWIG_From_int((int)(result));
5522 }
5523 return resultobj;
5524 fail:
5525 return NULL;
5526 }
5527
5528
5529 static PyObject *_wrap_Icon_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5530 PyObject *resultobj;
5531 wxIcon *arg1 = (wxIcon *) 0 ;
5532 int result;
5533 PyObject * obj0 = 0 ;
5534 char *kwnames[] = {
5535 (char *) "self", NULL
5536 };
5537
5538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetDepth",kwnames,&obj0)) goto fail;
5539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5540 if (SWIG_arg_fail(1)) SWIG_fail;
5541 {
5542 PyThreadState* __tstate = wxPyBeginAllowThreads();
5543 result = (int)(arg1)->GetDepth();
5544
5545 wxPyEndAllowThreads(__tstate);
5546 if (PyErr_Occurred()) SWIG_fail;
5547 }
5548 {
5549 resultobj = SWIG_From_int((int)(result));
5550 }
5551 return resultobj;
5552 fail:
5553 return NULL;
5554 }
5555
5556
5557 static PyObject *_wrap_Icon_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5558 PyObject *resultobj;
5559 wxIcon *arg1 = (wxIcon *) 0 ;
5560 int arg2 ;
5561 PyObject * obj0 = 0 ;
5562 PyObject * obj1 = 0 ;
5563 char *kwnames[] = {
5564 (char *) "self",(char *) "w", NULL
5565 };
5566
5567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5569 if (SWIG_arg_fail(1)) SWIG_fail;
5570 {
5571 arg2 = (int)(SWIG_As_int(obj1));
5572 if (SWIG_arg_fail(2)) SWIG_fail;
5573 }
5574 {
5575 PyThreadState* __tstate = wxPyBeginAllowThreads();
5576 (arg1)->SetWidth(arg2);
5577
5578 wxPyEndAllowThreads(__tstate);
5579 if (PyErr_Occurred()) SWIG_fail;
5580 }
5581 Py_INCREF(Py_None); resultobj = Py_None;
5582 return resultobj;
5583 fail:
5584 return NULL;
5585 }
5586
5587
5588 static PyObject *_wrap_Icon_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5589 PyObject *resultobj;
5590 wxIcon *arg1 = (wxIcon *) 0 ;
5591 int arg2 ;
5592 PyObject * obj0 = 0 ;
5593 PyObject * obj1 = 0 ;
5594 char *kwnames[] = {
5595 (char *) "self",(char *) "h", NULL
5596 };
5597
5598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5600 if (SWIG_arg_fail(1)) SWIG_fail;
5601 {
5602 arg2 = (int)(SWIG_As_int(obj1));
5603 if (SWIG_arg_fail(2)) SWIG_fail;
5604 }
5605 {
5606 PyThreadState* __tstate = wxPyBeginAllowThreads();
5607 (arg1)->SetHeight(arg2);
5608
5609 wxPyEndAllowThreads(__tstate);
5610 if (PyErr_Occurred()) SWIG_fail;
5611 }
5612 Py_INCREF(Py_None); resultobj = Py_None;
5613 return resultobj;
5614 fail:
5615 return NULL;
5616 }
5617
5618
5619 static PyObject *_wrap_Icon_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5620 PyObject *resultobj;
5621 wxIcon *arg1 = (wxIcon *) 0 ;
5622 int arg2 ;
5623 PyObject * obj0 = 0 ;
5624 PyObject * obj1 = 0 ;
5625 char *kwnames[] = {
5626 (char *) "self",(char *) "d", NULL
5627 };
5628
5629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetDepth",kwnames,&obj0,&obj1)) goto fail;
5630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5631 if (SWIG_arg_fail(1)) SWIG_fail;
5632 {
5633 arg2 = (int)(SWIG_As_int(obj1));
5634 if (SWIG_arg_fail(2)) SWIG_fail;
5635 }
5636 {
5637 PyThreadState* __tstate = wxPyBeginAllowThreads();
5638 (arg1)->SetDepth(arg2);
5639
5640 wxPyEndAllowThreads(__tstate);
5641 if (PyErr_Occurred()) SWIG_fail;
5642 }
5643 Py_INCREF(Py_None); resultobj = Py_None;
5644 return resultobj;
5645 fail:
5646 return NULL;
5647 }
5648
5649
5650 static PyObject *_wrap_Icon_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5651 PyObject *resultobj;
5652 wxIcon *arg1 = (wxIcon *) 0 ;
5653 wxSize *arg2 = 0 ;
5654 wxSize temp2 ;
5655 PyObject * obj0 = 0 ;
5656 PyObject * obj1 = 0 ;
5657 char *kwnames[] = {
5658 (char *) "self",(char *) "size", NULL
5659 };
5660
5661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetSize",kwnames,&obj0,&obj1)) goto fail;
5662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5663 if (SWIG_arg_fail(1)) SWIG_fail;
5664 {
5665 arg2 = &temp2;
5666 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5667 }
5668 {
5669 PyThreadState* __tstate = wxPyBeginAllowThreads();
5670 (arg1)->SetSize((wxSize const &)*arg2);
5671
5672 wxPyEndAllowThreads(__tstate);
5673 if (PyErr_Occurred()) SWIG_fail;
5674 }
5675 Py_INCREF(Py_None); resultobj = Py_None;
5676 return resultobj;
5677 fail:
5678 return NULL;
5679 }
5680
5681
5682 static PyObject *_wrap_Icon_CopyFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5683 PyObject *resultobj;
5684 wxIcon *arg1 = (wxIcon *) 0 ;
5685 wxBitmap *arg2 = 0 ;
5686 PyObject * obj0 = 0 ;
5687 PyObject * obj1 = 0 ;
5688 char *kwnames[] = {
5689 (char *) "self",(char *) "bmp", NULL
5690 };
5691
5692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_CopyFromBitmap",kwnames,&obj0,&obj1)) goto fail;
5693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5694 if (SWIG_arg_fail(1)) SWIG_fail;
5695 {
5696 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5697 if (SWIG_arg_fail(2)) SWIG_fail;
5698 if (arg2 == NULL) {
5699 SWIG_null_ref("wxBitmap");
5700 }
5701 if (SWIG_arg_fail(2)) SWIG_fail;
5702 }
5703 {
5704 PyThreadState* __tstate = wxPyBeginAllowThreads();
5705 (arg1)->CopyFromBitmap((wxBitmap const &)*arg2);
5706
5707 wxPyEndAllowThreads(__tstate);
5708 if (PyErr_Occurred()) SWIG_fail;
5709 }
5710 Py_INCREF(Py_None); resultobj = Py_None;
5711 return resultobj;
5712 fail:
5713 return NULL;
5714 }
5715
5716
5717 static PyObject * Icon_swigregister(PyObject *, PyObject *args) {
5718 PyObject *obj;
5719 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5720 SWIG_TypeClientData(SWIGTYPE_p_wxIcon, obj);
5721 Py_INCREF(obj);
5722 return Py_BuildValue((char *)"");
5723 }
5724 static PyObject *_wrap_new_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5725 PyObject *resultobj;
5726 wxString *arg1 = (wxString *) &wxPyEmptyString ;
5727 int arg2 = (int) 0 ;
5728 wxIconLocation *result;
5729 bool temp1 = false ;
5730 PyObject * obj0 = 0 ;
5731 PyObject * obj1 = 0 ;
5732 char *kwnames[] = {
5733 (char *) "filename",(char *) "num", NULL
5734 };
5735
5736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconLocation",kwnames,&obj0,&obj1)) goto fail;
5737 if (obj0) {
5738 {
5739 arg1 = wxString_in_helper(obj0);
5740 if (arg1 == NULL) SWIG_fail;
5741 temp1 = true;
5742 }
5743 }
5744 if (obj1) {
5745 {
5746 arg2 = (int)(SWIG_As_int(obj1));
5747 if (SWIG_arg_fail(2)) SWIG_fail;
5748 }
5749 }
5750 {
5751 PyThreadState* __tstate = wxPyBeginAllowThreads();
5752 result = (wxIconLocation *)new_wxIconLocation((wxString const *)arg1,arg2);
5753
5754 wxPyEndAllowThreads(__tstate);
5755 if (PyErr_Occurred()) SWIG_fail;
5756 }
5757 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconLocation, 1);
5758 {
5759 if (temp1)
5760 delete arg1;
5761 }
5762 return resultobj;
5763 fail:
5764 {
5765 if (temp1)
5766 delete arg1;
5767 }
5768 return NULL;
5769 }
5770
5771
5772 static PyObject *_wrap_delete_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5773 PyObject *resultobj;
5774 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5775 PyObject * obj0 = 0 ;
5776 char *kwnames[] = {
5777 (char *) "self", NULL
5778 };
5779
5780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconLocation",kwnames,&obj0)) goto fail;
5781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5782 if (SWIG_arg_fail(1)) SWIG_fail;
5783 {
5784 PyThreadState* __tstate = wxPyBeginAllowThreads();
5785 delete arg1;
5786
5787 wxPyEndAllowThreads(__tstate);
5788 if (PyErr_Occurred()) SWIG_fail;
5789 }
5790 Py_INCREF(Py_None); resultobj = Py_None;
5791 return resultobj;
5792 fail:
5793 return NULL;
5794 }
5795
5796
5797 static PyObject *_wrap_IconLocation_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
5798 PyObject *resultobj;
5799 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5800 bool result;
5801 PyObject * obj0 = 0 ;
5802 char *kwnames[] = {
5803 (char *) "self", NULL
5804 };
5805
5806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_IsOk",kwnames,&obj0)) goto fail;
5807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5808 if (SWIG_arg_fail(1)) SWIG_fail;
5809 {
5810 PyThreadState* __tstate = wxPyBeginAllowThreads();
5811 result = (bool)((wxIconLocation const *)arg1)->IsOk();
5812
5813 wxPyEndAllowThreads(__tstate);
5814 if (PyErr_Occurred()) SWIG_fail;
5815 }
5816 {
5817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5818 }
5819 return resultobj;
5820 fail:
5821 return NULL;
5822 }
5823
5824
5825 static PyObject *_wrap_IconLocation_SetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5826 PyObject *resultobj;
5827 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5828 wxString *arg2 = 0 ;
5829 bool temp2 = false ;
5830 PyObject * obj0 = 0 ;
5831 PyObject * obj1 = 0 ;
5832 char *kwnames[] = {
5833 (char *) "self",(char *) "filename", NULL
5834 };
5835
5836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetFileName",kwnames,&obj0,&obj1)) goto fail;
5837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5838 if (SWIG_arg_fail(1)) SWIG_fail;
5839 {
5840 arg2 = wxString_in_helper(obj1);
5841 if (arg2 == NULL) SWIG_fail;
5842 temp2 = true;
5843 }
5844 {
5845 PyThreadState* __tstate = wxPyBeginAllowThreads();
5846 (arg1)->SetFileName((wxString const &)*arg2);
5847
5848 wxPyEndAllowThreads(__tstate);
5849 if (PyErr_Occurred()) SWIG_fail;
5850 }
5851 Py_INCREF(Py_None); resultobj = Py_None;
5852 {
5853 if (temp2)
5854 delete arg2;
5855 }
5856 return resultobj;
5857 fail:
5858 {
5859 if (temp2)
5860 delete arg2;
5861 }
5862 return NULL;
5863 }
5864
5865
5866 static PyObject *_wrap_IconLocation_GetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5867 PyObject *resultobj;
5868 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5869 wxString *result;
5870 PyObject * obj0 = 0 ;
5871 char *kwnames[] = {
5872 (char *) "self", NULL
5873 };
5874
5875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetFileName",kwnames,&obj0)) goto fail;
5876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5877 if (SWIG_arg_fail(1)) SWIG_fail;
5878 {
5879 PyThreadState* __tstate = wxPyBeginAllowThreads();
5880 {
5881 wxString const &_result_ref = ((wxIconLocation const *)arg1)->GetFileName();
5882 result = (wxString *) &_result_ref;
5883 }
5884
5885 wxPyEndAllowThreads(__tstate);
5886 if (PyErr_Occurred()) SWIG_fail;
5887 }
5888 {
5889 #if wxUSE_UNICODE
5890 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
5891 #else
5892 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
5893 #endif
5894 }
5895 return resultobj;
5896 fail:
5897 return NULL;
5898 }
5899
5900
5901 static PyObject *_wrap_IconLocation_SetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5902 PyObject *resultobj;
5903 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5904 int arg2 ;
5905 PyObject * obj0 = 0 ;
5906 PyObject * obj1 = 0 ;
5907 char *kwnames[] = {
5908 (char *) "self",(char *) "num", NULL
5909 };
5910
5911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetIndex",kwnames,&obj0,&obj1)) goto fail;
5912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5913 if (SWIG_arg_fail(1)) SWIG_fail;
5914 {
5915 arg2 = (int)(SWIG_As_int(obj1));
5916 if (SWIG_arg_fail(2)) SWIG_fail;
5917 }
5918 {
5919 PyThreadState* __tstate = wxPyBeginAllowThreads();
5920 wxIconLocation_SetIndex(arg1,arg2);
5921
5922 wxPyEndAllowThreads(__tstate);
5923 if (PyErr_Occurred()) SWIG_fail;
5924 }
5925 Py_INCREF(Py_None); resultobj = Py_None;
5926 return resultobj;
5927 fail:
5928 return NULL;
5929 }
5930
5931
5932 static PyObject *_wrap_IconLocation_GetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5933 PyObject *resultobj;
5934 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5935 int result;
5936 PyObject * obj0 = 0 ;
5937 char *kwnames[] = {
5938 (char *) "self", NULL
5939 };
5940
5941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetIndex",kwnames,&obj0)) goto fail;
5942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5943 if (SWIG_arg_fail(1)) SWIG_fail;
5944 {
5945 PyThreadState* __tstate = wxPyBeginAllowThreads();
5946 result = (int)wxIconLocation_GetIndex(arg1);
5947
5948 wxPyEndAllowThreads(__tstate);
5949 if (PyErr_Occurred()) SWIG_fail;
5950 }
5951 {
5952 resultobj = SWIG_From_int((int)(result));
5953 }
5954 return resultobj;
5955 fail:
5956 return NULL;
5957 }
5958
5959
5960 static PyObject * IconLocation_swigregister(PyObject *, PyObject *args) {
5961 PyObject *obj;
5962 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5963 SWIG_TypeClientData(SWIGTYPE_p_wxIconLocation, obj);
5964 Py_INCREF(obj);
5965 return Py_BuildValue((char *)"");
5966 }
5967 static PyObject *_wrap_new_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5968 PyObject *resultobj;
5969 wxIconBundle *result;
5970 char *kwnames[] = {
5971 NULL
5972 };
5973
5974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IconBundle",kwnames)) goto fail;
5975 {
5976 PyThreadState* __tstate = wxPyBeginAllowThreads();
5977 result = (wxIconBundle *)new wxIconBundle();
5978
5979 wxPyEndAllowThreads(__tstate);
5980 if (PyErr_Occurred()) SWIG_fail;
5981 }
5982 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5983 return resultobj;
5984 fail:
5985 return NULL;
5986 }
5987
5988
5989 static PyObject *_wrap_new_IconBundleFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5990 PyObject *resultobj;
5991 wxString *arg1 = 0 ;
5992 long arg2 ;
5993 wxIconBundle *result;
5994 bool temp1 = false ;
5995 PyObject * obj0 = 0 ;
5996 PyObject * obj1 = 0 ;
5997 char *kwnames[] = {
5998 (char *) "file",(char *) "type", NULL
5999 };
6000
6001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_IconBundleFromFile",kwnames,&obj0,&obj1)) goto fail;
6002 {
6003 arg1 = wxString_in_helper(obj0);
6004 if (arg1 == NULL) SWIG_fail;
6005 temp1 = true;
6006 }
6007 {
6008 arg2 = (long)(SWIG_As_long(obj1));
6009 if (SWIG_arg_fail(2)) SWIG_fail;
6010 }
6011 {
6012 PyThreadState* __tstate = wxPyBeginAllowThreads();
6013 result = (wxIconBundle *)new wxIconBundle((wxString const &)*arg1,arg2);
6014
6015 wxPyEndAllowThreads(__tstate);
6016 if (PyErr_Occurred()) SWIG_fail;
6017 }
6018 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
6019 {
6020 if (temp1)
6021 delete arg1;
6022 }
6023 return resultobj;
6024 fail:
6025 {
6026 if (temp1)
6027 delete arg1;
6028 }
6029 return NULL;
6030 }
6031
6032
6033 static PyObject *_wrap_new_IconBundleFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
6034 PyObject *resultobj;
6035 wxIcon *arg1 = 0 ;
6036 wxIconBundle *result;
6037 PyObject * obj0 = 0 ;
6038 char *kwnames[] = {
6039 (char *) "icon", NULL
6040 };
6041
6042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconBundleFromIcon",kwnames,&obj0)) goto fail;
6043 {
6044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
6045 if (SWIG_arg_fail(1)) SWIG_fail;
6046 if (arg1 == NULL) {
6047 SWIG_null_ref("wxIcon");
6048 }
6049 if (SWIG_arg_fail(1)) SWIG_fail;
6050 }
6051 {
6052 PyThreadState* __tstate = wxPyBeginAllowThreads();
6053 result = (wxIconBundle *)new wxIconBundle((wxIcon const &)*arg1);
6054
6055 wxPyEndAllowThreads(__tstate);
6056 if (PyErr_Occurred()) SWIG_fail;
6057 }
6058 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
6059 return resultobj;
6060 fail:
6061 return NULL;
6062 }
6063
6064
6065 static PyObject *_wrap_delete_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
6066 PyObject *resultobj;
6067 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
6068 PyObject * obj0 = 0 ;
6069 char *kwnames[] = {
6070 (char *) "self", NULL
6071 };
6072
6073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconBundle",kwnames,&obj0)) goto fail;
6074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
6075 if (SWIG_arg_fail(1)) SWIG_fail;
6076 {
6077 PyThreadState* __tstate = wxPyBeginAllowThreads();
6078 delete arg1;
6079
6080 wxPyEndAllowThreads(__tstate);
6081 if (PyErr_Occurred()) SWIG_fail;
6082 }
6083 Py_INCREF(Py_None); resultobj = Py_None;
6084 return resultobj;
6085 fail:
6086 return NULL;
6087 }
6088
6089
6090 static PyObject *_wrap_IconBundle_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
6091 PyObject *resultobj;
6092 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
6093 wxIcon *arg2 = 0 ;
6094 PyObject * obj0 = 0 ;
6095 PyObject * obj1 = 0 ;
6096 char *kwnames[] = {
6097 (char *) "self",(char *) "icon", NULL
6098 };
6099
6100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_AddIcon",kwnames,&obj0,&obj1)) goto fail;
6101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
6102 if (SWIG_arg_fail(1)) SWIG_fail;
6103 {
6104 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
6105 if (SWIG_arg_fail(2)) SWIG_fail;
6106 if (arg2 == NULL) {
6107 SWIG_null_ref("wxIcon");
6108 }
6109 if (SWIG_arg_fail(2)) SWIG_fail;
6110 }
6111 {
6112 PyThreadState* __tstate = wxPyBeginAllowThreads();
6113 (arg1)->AddIcon((wxIcon const &)*arg2);
6114
6115 wxPyEndAllowThreads(__tstate);
6116 if (PyErr_Occurred()) SWIG_fail;
6117 }
6118 Py_INCREF(Py_None); resultobj = Py_None;
6119 return resultobj;
6120 fail:
6121 return NULL;
6122 }
6123
6124
6125 static PyObject *_wrap_IconBundle_AddIconFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
6126 PyObject *resultobj;
6127 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
6128 wxString *arg2 = 0 ;
6129 long arg3 ;
6130 bool temp2 = false ;
6131 PyObject * obj0 = 0 ;
6132 PyObject * obj1 = 0 ;
6133 PyObject * obj2 = 0 ;
6134 char *kwnames[] = {
6135 (char *) "self",(char *) "file",(char *) "type", NULL
6136 };
6137
6138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IconBundle_AddIconFromFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
6139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
6140 if (SWIG_arg_fail(1)) SWIG_fail;
6141 {
6142 arg2 = wxString_in_helper(obj1);
6143 if (arg2 == NULL) SWIG_fail;
6144 temp2 = true;
6145 }
6146 {
6147 arg3 = (long)(SWIG_As_long(obj2));
6148 if (SWIG_arg_fail(3)) SWIG_fail;
6149 }
6150 {
6151 PyThreadState* __tstate = wxPyBeginAllowThreads();
6152 (arg1)->AddIcon((wxString const &)*arg2,arg3);
6153
6154 wxPyEndAllowThreads(__tstate);
6155 if (PyErr_Occurred()) SWIG_fail;
6156 }
6157 Py_INCREF(Py_None); resultobj = Py_None;
6158 {
6159 if (temp2)
6160 delete arg2;
6161 }
6162 return resultobj;
6163 fail:
6164 {
6165 if (temp2)
6166 delete arg2;
6167 }
6168 return NULL;
6169 }
6170
6171
6172 static PyObject *_wrap_IconBundle_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
6173 PyObject *resultobj;
6174 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
6175 wxSize *arg2 = 0 ;
6176 wxIcon *result;
6177 wxSize temp2 ;
6178 PyObject * obj0 = 0 ;
6179 PyObject * obj1 = 0 ;
6180 char *kwnames[] = {
6181 (char *) "self",(char *) "size", NULL
6182 };
6183
6184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_GetIcon",kwnames,&obj0,&obj1)) goto fail;
6185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
6186 if (SWIG_arg_fail(1)) SWIG_fail;
6187 {
6188 arg2 = &temp2;
6189 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6190 }
6191 {
6192 PyThreadState* __tstate = wxPyBeginAllowThreads();
6193 {
6194 wxIcon const &_result_ref = ((wxIconBundle const *)arg1)->GetIcon((wxSize const &)*arg2);
6195 result = (wxIcon *) &_result_ref;
6196 }
6197
6198 wxPyEndAllowThreads(__tstate);
6199 if (PyErr_Occurred()) SWIG_fail;
6200 }
6201 {
6202 wxIcon* resultptr = new wxIcon(*result);
6203 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxIcon, 1);
6204 }
6205 return resultobj;
6206 fail:
6207 return NULL;
6208 }
6209
6210
6211 static PyObject * IconBundle_swigregister(PyObject *, PyObject *args) {
6212 PyObject *obj;
6213 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6214 SWIG_TypeClientData(SWIGTYPE_p_wxIconBundle, obj);
6215 Py_INCREF(obj);
6216 return Py_BuildValue((char *)"");
6217 }
6218 static PyObject *_wrap_new_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
6219 PyObject *resultobj;
6220 wxString *arg1 = 0 ;
6221 long arg2 ;
6222 int arg3 = (int) 0 ;
6223 int arg4 = (int) 0 ;
6224 wxCursor *result;
6225 bool temp1 = false ;
6226 PyObject * obj0 = 0 ;
6227 PyObject * obj1 = 0 ;
6228 PyObject * obj2 = 0 ;
6229 PyObject * obj3 = 0 ;
6230 char *kwnames[] = {
6231 (char *) "cursorName",(char *) "type",(char *) "hotSpotX",(char *) "hotSpotY", NULL
6232 };
6233
6234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Cursor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6235 {
6236 arg1 = wxString_in_helper(obj0);
6237 if (arg1 == NULL) SWIG_fail;
6238 temp1 = true;
6239 }
6240 {
6241 arg2 = (long)(SWIG_As_long(obj1));
6242 if (SWIG_arg_fail(2)) SWIG_fail;
6243 }
6244 if (obj2) {
6245 {
6246 arg3 = (int)(SWIG_As_int(obj2));
6247 if (SWIG_arg_fail(3)) SWIG_fail;
6248 }
6249 }
6250 if (obj3) {
6251 {
6252 arg4 = (int)(SWIG_As_int(obj3));
6253 if (SWIG_arg_fail(4)) SWIG_fail;
6254 }
6255 }
6256 {
6257 if (!wxPyCheckForApp()) SWIG_fail;
6258 PyThreadState* __tstate = wxPyBeginAllowThreads();
6259 result = (wxCursor *)new_wxCursor((wxString const &)*arg1,arg2,arg3,arg4);
6260
6261 wxPyEndAllowThreads(__tstate);
6262 if (PyErr_Occurred()) SWIG_fail;
6263 }
6264 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6265 {
6266 if (temp1)
6267 delete arg1;
6268 }
6269 return resultobj;
6270 fail:
6271 {
6272 if (temp1)
6273 delete arg1;
6274 }
6275 return NULL;
6276 }
6277
6278
6279 static PyObject *_wrap_delete_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
6280 PyObject *resultobj;
6281 wxCursor *arg1 = (wxCursor *) 0 ;
6282 PyObject * obj0 = 0 ;
6283 char *kwnames[] = {
6284 (char *) "self", NULL
6285 };
6286
6287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Cursor",kwnames,&obj0)) goto fail;
6288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6289 if (SWIG_arg_fail(1)) SWIG_fail;
6290 {
6291 PyThreadState* __tstate = wxPyBeginAllowThreads();
6292 delete arg1;
6293
6294 wxPyEndAllowThreads(__tstate);
6295 if (PyErr_Occurred()) SWIG_fail;
6296 }
6297 Py_INCREF(Py_None); resultobj = Py_None;
6298 return resultobj;
6299 fail:
6300 return NULL;
6301 }
6302
6303
6304 static PyObject *_wrap_new_StockCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6305 PyObject *resultobj;
6306 int arg1 ;
6307 wxCursor *result;
6308 PyObject * obj0 = 0 ;
6309 char *kwnames[] = {
6310 (char *) "id", NULL
6311 };
6312
6313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_StockCursor",kwnames,&obj0)) goto fail;
6314 {
6315 arg1 = (int)(SWIG_As_int(obj0));
6316 if (SWIG_arg_fail(1)) SWIG_fail;
6317 }
6318 {
6319 if (!wxPyCheckForApp()) SWIG_fail;
6320 PyThreadState* __tstate = wxPyBeginAllowThreads();
6321 result = (wxCursor *)new wxCursor(arg1);
6322
6323 wxPyEndAllowThreads(__tstate);
6324 if (PyErr_Occurred()) SWIG_fail;
6325 }
6326 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6327 return resultobj;
6328 fail:
6329 return NULL;
6330 }
6331
6332
6333 static PyObject *_wrap_new_CursorFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
6334 PyObject *resultobj;
6335 wxImage *arg1 = 0 ;
6336 wxCursor *result;
6337 PyObject * obj0 = 0 ;
6338 char *kwnames[] = {
6339 (char *) "image", NULL
6340 };
6341
6342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CursorFromImage",kwnames,&obj0)) goto fail;
6343 {
6344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
6345 if (SWIG_arg_fail(1)) SWIG_fail;
6346 if (arg1 == NULL) {
6347 SWIG_null_ref("wxImage");
6348 }
6349 if (SWIG_arg_fail(1)) SWIG_fail;
6350 }
6351 {
6352 if (!wxPyCheckForApp()) SWIG_fail;
6353 PyThreadState* __tstate = wxPyBeginAllowThreads();
6354 result = (wxCursor *)new wxCursor((wxImage const &)*arg1);
6355
6356 wxPyEndAllowThreads(__tstate);
6357 if (PyErr_Occurred()) SWIG_fail;
6358 }
6359 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6360 return resultobj;
6361 fail:
6362 return NULL;
6363 }
6364
6365
6366 static PyObject *_wrap_Cursor_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
6367 PyObject *resultobj;
6368 wxCursor *arg1 = (wxCursor *) 0 ;
6369 long result;
6370 PyObject * obj0 = 0 ;
6371 char *kwnames[] = {
6372 (char *) "self", NULL
6373 };
6374
6375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_GetHandle",kwnames,&obj0)) goto fail;
6376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6377 if (SWIG_arg_fail(1)) SWIG_fail;
6378 {
6379 PyThreadState* __tstate = wxPyBeginAllowThreads();
6380 result = (long)(arg1)->GetHandle();
6381
6382 wxPyEndAllowThreads(__tstate);
6383 if (PyErr_Occurred()) SWIG_fail;
6384 }
6385 {
6386 resultobj = SWIG_From_long((long)(result));
6387 }
6388 return resultobj;
6389 fail:
6390 return NULL;
6391 }
6392
6393
6394 static PyObject *_wrap_Cursor_SetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
6395 PyObject *resultobj;
6396 wxCursor *arg1 = (wxCursor *) 0 ;
6397 long arg2 ;
6398 PyObject * obj0 = 0 ;
6399 PyObject * obj1 = 0 ;
6400 char *kwnames[] = {
6401 (char *) "self",(char *) "handle", NULL
6402 };
6403
6404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetHandle",kwnames,&obj0,&obj1)) goto fail;
6405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6406 if (SWIG_arg_fail(1)) SWIG_fail;
6407 {
6408 arg2 = (long)(SWIG_As_long(obj1));
6409 if (SWIG_arg_fail(2)) SWIG_fail;
6410 }
6411 {
6412 PyThreadState* __tstate = wxPyBeginAllowThreads();
6413 wxCursor_SetHandle(arg1,arg2);
6414
6415 wxPyEndAllowThreads(__tstate);
6416 if (PyErr_Occurred()) SWIG_fail;
6417 }
6418 Py_INCREF(Py_None); resultobj = Py_None;
6419 return resultobj;
6420 fail:
6421 return NULL;
6422 }
6423
6424
6425 static PyObject *_wrap_Cursor_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
6426 PyObject *resultobj;
6427 wxCursor *arg1 = (wxCursor *) 0 ;
6428 bool result;
6429 PyObject * obj0 = 0 ;
6430 char *kwnames[] = {
6431 (char *) "self", NULL
6432 };
6433
6434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_Ok",kwnames,&obj0)) goto fail;
6435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6436 if (SWIG_arg_fail(1)) SWIG_fail;
6437 {
6438 PyThreadState* __tstate = wxPyBeginAllowThreads();
6439 result = (bool)(arg1)->Ok();
6440
6441 wxPyEndAllowThreads(__tstate);
6442 if (PyErr_Occurred()) SWIG_fail;
6443 }
6444 {
6445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6446 }
6447 return resultobj;
6448 fail:
6449 return NULL;
6450 }
6451
6452
6453 static PyObject *_wrap_Cursor_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
6454 PyObject *resultobj;
6455 wxCursor *arg1 = (wxCursor *) 0 ;
6456 int result;
6457 PyObject * obj0 = 0 ;
6458 char *kwnames[] = {
6459 (char *) "self", NULL
6460 };
6461
6462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_GetWidth",kwnames,&obj0)) goto fail;
6463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6464 if (SWIG_arg_fail(1)) SWIG_fail;
6465 {
6466 PyThreadState* __tstate = wxPyBeginAllowThreads();
6467 result = (int)(arg1)->GetWidth();
6468
6469 wxPyEndAllowThreads(__tstate);
6470 if (PyErr_Occurred()) SWIG_fail;
6471 }
6472 {
6473 resultobj = SWIG_From_int((int)(result));
6474 }
6475 return resultobj;
6476 fail:
6477 return NULL;
6478 }
6479
6480
6481 static PyObject *_wrap_Cursor_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
6482 PyObject *resultobj;
6483 wxCursor *arg1 = (wxCursor *) 0 ;
6484 int result;
6485 PyObject * obj0 = 0 ;
6486 char *kwnames[] = {
6487 (char *) "self", NULL
6488 };
6489
6490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_GetHeight",kwnames,&obj0)) goto fail;
6491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6492 if (SWIG_arg_fail(1)) SWIG_fail;
6493 {
6494 PyThreadState* __tstate = wxPyBeginAllowThreads();
6495 result = (int)(arg1)->GetHeight();
6496
6497 wxPyEndAllowThreads(__tstate);
6498 if (PyErr_Occurred()) SWIG_fail;
6499 }
6500 {
6501 resultobj = SWIG_From_int((int)(result));
6502 }
6503 return resultobj;
6504 fail:
6505 return NULL;
6506 }
6507
6508
6509 static PyObject *_wrap_Cursor_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
6510 PyObject *resultobj;
6511 wxCursor *arg1 = (wxCursor *) 0 ;
6512 int result;
6513 PyObject * obj0 = 0 ;
6514 char *kwnames[] = {
6515 (char *) "self", NULL
6516 };
6517
6518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_GetDepth",kwnames,&obj0)) goto fail;
6519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6520 if (SWIG_arg_fail(1)) SWIG_fail;
6521 {
6522 PyThreadState* __tstate = wxPyBeginAllowThreads();
6523 result = (int)(arg1)->GetDepth();
6524
6525 wxPyEndAllowThreads(__tstate);
6526 if (PyErr_Occurred()) SWIG_fail;
6527 }
6528 {
6529 resultobj = SWIG_From_int((int)(result));
6530 }
6531 return resultobj;
6532 fail:
6533 return NULL;
6534 }
6535
6536
6537 static PyObject *_wrap_Cursor_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
6538 PyObject *resultobj;
6539 wxCursor *arg1 = (wxCursor *) 0 ;
6540 int arg2 ;
6541 PyObject * obj0 = 0 ;
6542 PyObject * obj1 = 0 ;
6543 char *kwnames[] = {
6544 (char *) "self",(char *) "w", NULL
6545 };
6546
6547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetWidth",kwnames,&obj0,&obj1)) goto fail;
6548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6549 if (SWIG_arg_fail(1)) SWIG_fail;
6550 {
6551 arg2 = (int)(SWIG_As_int(obj1));
6552 if (SWIG_arg_fail(2)) SWIG_fail;
6553 }
6554 {
6555 PyThreadState* __tstate = wxPyBeginAllowThreads();
6556 (arg1)->SetWidth(arg2);
6557
6558 wxPyEndAllowThreads(__tstate);
6559 if (PyErr_Occurred()) SWIG_fail;
6560 }
6561 Py_INCREF(Py_None); resultobj = Py_None;
6562 return resultobj;
6563 fail:
6564 return NULL;
6565 }
6566
6567
6568 static PyObject *_wrap_Cursor_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
6569 PyObject *resultobj;
6570 wxCursor *arg1 = (wxCursor *) 0 ;
6571 int arg2 ;
6572 PyObject * obj0 = 0 ;
6573 PyObject * obj1 = 0 ;
6574 char *kwnames[] = {
6575 (char *) "self",(char *) "h", NULL
6576 };
6577
6578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetHeight",kwnames,&obj0,&obj1)) goto fail;
6579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6580 if (SWIG_arg_fail(1)) SWIG_fail;
6581 {
6582 arg2 = (int)(SWIG_As_int(obj1));
6583 if (SWIG_arg_fail(2)) SWIG_fail;
6584 }
6585 {
6586 PyThreadState* __tstate = wxPyBeginAllowThreads();
6587 (arg1)->SetHeight(arg2);
6588
6589 wxPyEndAllowThreads(__tstate);
6590 if (PyErr_Occurred()) SWIG_fail;
6591 }
6592 Py_INCREF(Py_None); resultobj = Py_None;
6593 return resultobj;
6594 fail:
6595 return NULL;
6596 }
6597
6598
6599 static PyObject *_wrap_Cursor_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
6600 PyObject *resultobj;
6601 wxCursor *arg1 = (wxCursor *) 0 ;
6602 int arg2 ;
6603 PyObject * obj0 = 0 ;
6604 PyObject * obj1 = 0 ;
6605 char *kwnames[] = {
6606 (char *) "self",(char *) "d", NULL
6607 };
6608
6609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetDepth",kwnames,&obj0,&obj1)) goto fail;
6610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6611 if (SWIG_arg_fail(1)) SWIG_fail;
6612 {
6613 arg2 = (int)(SWIG_As_int(obj1));
6614 if (SWIG_arg_fail(2)) SWIG_fail;
6615 }
6616 {
6617 PyThreadState* __tstate = wxPyBeginAllowThreads();
6618 (arg1)->SetDepth(arg2);
6619
6620 wxPyEndAllowThreads(__tstate);
6621 if (PyErr_Occurred()) SWIG_fail;
6622 }
6623 Py_INCREF(Py_None); resultobj = Py_None;
6624 return resultobj;
6625 fail:
6626 return NULL;
6627 }
6628
6629
6630 static PyObject *_wrap_Cursor_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6631 PyObject *resultobj;
6632 wxCursor *arg1 = (wxCursor *) 0 ;
6633 wxSize *arg2 = 0 ;
6634 wxSize temp2 ;
6635 PyObject * obj0 = 0 ;
6636 PyObject * obj1 = 0 ;
6637 char *kwnames[] = {
6638 (char *) "self",(char *) "size", NULL
6639 };
6640
6641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetSize",kwnames,&obj0,&obj1)) goto fail;
6642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6643 if (SWIG_arg_fail(1)) SWIG_fail;
6644 {
6645 arg2 = &temp2;
6646 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6647 }
6648 {
6649 PyThreadState* __tstate = wxPyBeginAllowThreads();
6650 (arg1)->SetSize((wxSize const &)*arg2);
6651
6652 wxPyEndAllowThreads(__tstate);
6653 if (PyErr_Occurred()) SWIG_fail;
6654 }
6655 Py_INCREF(Py_None); resultobj = Py_None;
6656 return resultobj;
6657 fail:
6658 return NULL;
6659 }
6660
6661
6662 static PyObject * Cursor_swigregister(PyObject *, PyObject *args) {
6663 PyObject *obj;
6664 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6665 SWIG_TypeClientData(SWIGTYPE_p_wxCursor, obj);
6666 Py_INCREF(obj);
6667 return Py_BuildValue((char *)"");
6668 }
6669 static PyObject *_wrap_new_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6670 PyObject *resultobj;
6671 int arg1 = (int) 0 ;
6672 int arg2 = (int) 0 ;
6673 int arg3 = (int) 0 ;
6674 int arg4 = (int) 0 ;
6675 wxRegion *result;
6676 PyObject * obj0 = 0 ;
6677 PyObject * obj1 = 0 ;
6678 PyObject * obj2 = 0 ;
6679 PyObject * obj3 = 0 ;
6680 char *kwnames[] = {
6681 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6682 };
6683
6684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Region",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6685 if (obj0) {
6686 {
6687 arg1 = (int)(SWIG_As_int(obj0));
6688 if (SWIG_arg_fail(1)) SWIG_fail;
6689 }
6690 }
6691 if (obj1) {
6692 {
6693 arg2 = (int)(SWIG_As_int(obj1));
6694 if (SWIG_arg_fail(2)) SWIG_fail;
6695 }
6696 }
6697 if (obj2) {
6698 {
6699 arg3 = (int)(SWIG_As_int(obj2));
6700 if (SWIG_arg_fail(3)) SWIG_fail;
6701 }
6702 }
6703 if (obj3) {
6704 {
6705 arg4 = (int)(SWIG_As_int(obj3));
6706 if (SWIG_arg_fail(4)) SWIG_fail;
6707 }
6708 }
6709 {
6710 if (!wxPyCheckForApp()) SWIG_fail;
6711 PyThreadState* __tstate = wxPyBeginAllowThreads();
6712 result = (wxRegion *)new wxRegion(arg1,arg2,arg3,arg4);
6713
6714 wxPyEndAllowThreads(__tstate);
6715 if (PyErr_Occurred()) SWIG_fail;
6716 }
6717 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6718 return resultobj;
6719 fail:
6720 return NULL;
6721 }
6722
6723
6724 static PyObject *_wrap_new_RegionFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6725 PyObject *resultobj;
6726 wxBitmap *arg1 = 0 ;
6727 wxRegion *result;
6728 PyObject * obj0 = 0 ;
6729 char *kwnames[] = {
6730 (char *) "bmp", NULL
6731 };
6732
6733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionFromBitmap",kwnames,&obj0)) goto fail;
6734 {
6735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6736 if (SWIG_arg_fail(1)) SWIG_fail;
6737 if (arg1 == NULL) {
6738 SWIG_null_ref("wxBitmap");
6739 }
6740 if (SWIG_arg_fail(1)) SWIG_fail;
6741 }
6742 {
6743 if (!wxPyCheckForApp()) SWIG_fail;
6744 PyThreadState* __tstate = wxPyBeginAllowThreads();
6745 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1);
6746
6747 wxPyEndAllowThreads(__tstate);
6748 if (PyErr_Occurred()) SWIG_fail;
6749 }
6750 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6751 return resultobj;
6752 fail:
6753 return NULL;
6754 }
6755
6756
6757 static PyObject *_wrap_new_RegionFromBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
6758 PyObject *resultobj;
6759 wxBitmap *arg1 = 0 ;
6760 wxColour *arg2 = 0 ;
6761 int arg3 = (int) 0 ;
6762 wxRegion *result;
6763 wxColour temp2 ;
6764 PyObject * obj0 = 0 ;
6765 PyObject * obj1 = 0 ;
6766 PyObject * obj2 = 0 ;
6767 char *kwnames[] = {
6768 (char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
6769 };
6770
6771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_RegionFromBitmapColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
6772 {
6773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6774 if (SWIG_arg_fail(1)) SWIG_fail;
6775 if (arg1 == NULL) {
6776 SWIG_null_ref("wxBitmap");
6777 }
6778 if (SWIG_arg_fail(1)) SWIG_fail;
6779 }
6780 {
6781 arg2 = &temp2;
6782 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6783 }
6784 if (obj2) {
6785 {
6786 arg3 = (int)(SWIG_As_int(obj2));
6787 if (SWIG_arg_fail(3)) SWIG_fail;
6788 }
6789 }
6790 {
6791 if (!wxPyCheckForApp()) SWIG_fail;
6792 PyThreadState* __tstate = wxPyBeginAllowThreads();
6793 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1,(wxColour const &)*arg2,arg3);
6794
6795 wxPyEndAllowThreads(__tstate);
6796 if (PyErr_Occurred()) SWIG_fail;
6797 }
6798 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6799 return resultobj;
6800 fail:
6801 return NULL;
6802 }
6803
6804
6805 static PyObject *_wrap_new_RegionFromPoints(PyObject *, PyObject *args, PyObject *kwargs) {
6806 PyObject *resultobj;
6807 int arg1 ;
6808 wxPoint *arg2 = (wxPoint *) 0 ;
6809 int arg3 = (int) wxWINDING_RULE ;
6810 wxRegion *result;
6811 PyObject * obj0 = 0 ;
6812 PyObject * obj1 = 0 ;
6813 char *kwnames[] = {
6814 (char *) "points",(char *) "fillStyle", NULL
6815 };
6816
6817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_RegionFromPoints",kwnames,&obj0,&obj1)) goto fail;
6818 {
6819 arg2 = wxPoint_LIST_helper(obj0, &arg1);
6820 if (arg2 == NULL) SWIG_fail;
6821 }
6822 if (obj1) {
6823 {
6824 arg3 = (int)(SWIG_As_int(obj1));
6825 if (SWIG_arg_fail(3)) SWIG_fail;
6826 }
6827 }
6828 {
6829 if (!wxPyCheckForApp()) SWIG_fail;
6830 PyThreadState* __tstate = wxPyBeginAllowThreads();
6831 result = (wxRegion *)new wxRegion(arg1,arg2,arg3);
6832
6833 wxPyEndAllowThreads(__tstate);
6834 if (PyErr_Occurred()) SWIG_fail;
6835 }
6836 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6837 {
6838 if (arg2) delete [] arg2;
6839 }
6840 return resultobj;
6841 fail:
6842 {
6843 if (arg2) delete [] arg2;
6844 }
6845 return NULL;
6846 }
6847
6848
6849 static PyObject *_wrap_delete_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6850 PyObject *resultobj;
6851 wxRegion *arg1 = (wxRegion *) 0 ;
6852 PyObject * obj0 = 0 ;
6853 char *kwnames[] = {
6854 (char *) "self", NULL
6855 };
6856
6857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Region",kwnames,&obj0)) goto fail;
6858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6859 if (SWIG_arg_fail(1)) SWIG_fail;
6860 {
6861 PyThreadState* __tstate = wxPyBeginAllowThreads();
6862 delete arg1;
6863
6864 wxPyEndAllowThreads(__tstate);
6865 if (PyErr_Occurred()) SWIG_fail;
6866 }
6867 Py_INCREF(Py_None); resultobj = Py_None;
6868 return resultobj;
6869 fail:
6870 return NULL;
6871 }
6872
6873
6874 static PyObject *_wrap_Region_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
6875 PyObject *resultobj;
6876 wxRegion *arg1 = (wxRegion *) 0 ;
6877 PyObject * obj0 = 0 ;
6878 char *kwnames[] = {
6879 (char *) "self", NULL
6880 };
6881
6882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_Clear",kwnames,&obj0)) goto fail;
6883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6884 if (SWIG_arg_fail(1)) SWIG_fail;
6885 {
6886 PyThreadState* __tstate = wxPyBeginAllowThreads();
6887 (arg1)->Clear();
6888
6889 wxPyEndAllowThreads(__tstate);
6890 if (PyErr_Occurred()) SWIG_fail;
6891 }
6892 Py_INCREF(Py_None); resultobj = Py_None;
6893 return resultobj;
6894 fail:
6895 return NULL;
6896 }
6897
6898
6899 static PyObject *_wrap_Region_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
6900 PyObject *resultobj;
6901 wxRegion *arg1 = (wxRegion *) 0 ;
6902 int arg2 ;
6903 int arg3 ;
6904 bool result;
6905 PyObject * obj0 = 0 ;
6906 PyObject * obj1 = 0 ;
6907 PyObject * obj2 = 0 ;
6908 char *kwnames[] = {
6909 (char *) "self",(char *) "x",(char *) "y", NULL
6910 };
6911
6912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Offset",kwnames,&obj0,&obj1,&obj2)) goto fail;
6913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6914 if (SWIG_arg_fail(1)) SWIG_fail;
6915 {
6916 arg2 = (int)(SWIG_As_int(obj1));
6917 if (SWIG_arg_fail(2)) SWIG_fail;
6918 }
6919 {
6920 arg3 = (int)(SWIG_As_int(obj2));
6921 if (SWIG_arg_fail(3)) SWIG_fail;
6922 }
6923 {
6924 PyThreadState* __tstate = wxPyBeginAllowThreads();
6925 result = (bool)(arg1)->Offset(arg2,arg3);
6926
6927 wxPyEndAllowThreads(__tstate);
6928 if (PyErr_Occurred()) SWIG_fail;
6929 }
6930 {
6931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6932 }
6933 return resultobj;
6934 fail:
6935 return NULL;
6936 }
6937
6938
6939 static PyObject *_wrap_Region_Contains(PyObject *, PyObject *args, PyObject *kwargs) {
6940 PyObject *resultobj;
6941 wxRegion *arg1 = (wxRegion *) 0 ;
6942 int arg2 ;
6943 int arg3 ;
6944 wxRegionContain result;
6945 PyObject * obj0 = 0 ;
6946 PyObject * obj1 = 0 ;
6947 PyObject * obj2 = 0 ;
6948 char *kwnames[] = {
6949 (char *) "self",(char *) "x",(char *) "y", NULL
6950 };
6951
6952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Contains",kwnames,&obj0,&obj1,&obj2)) goto fail;
6953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6954 if (SWIG_arg_fail(1)) SWIG_fail;
6955 {
6956 arg2 = (int)(SWIG_As_int(obj1));
6957 if (SWIG_arg_fail(2)) SWIG_fail;
6958 }
6959 {
6960 arg3 = (int)(SWIG_As_int(obj2));
6961 if (SWIG_arg_fail(3)) SWIG_fail;
6962 }
6963 {
6964 PyThreadState* __tstate = wxPyBeginAllowThreads();
6965 result = (wxRegionContain)(arg1)->Contains(arg2,arg3);
6966
6967 wxPyEndAllowThreads(__tstate);
6968 if (PyErr_Occurred()) SWIG_fail;
6969 }
6970 resultobj = SWIG_From_int((result));
6971 return resultobj;
6972 fail:
6973 return NULL;
6974 }
6975
6976
6977 static PyObject *_wrap_Region_ContainsPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6978 PyObject *resultobj;
6979 wxRegion *arg1 = (wxRegion *) 0 ;
6980 wxPoint *arg2 = 0 ;
6981 wxRegionContain result;
6982 wxPoint temp2 ;
6983 PyObject * obj0 = 0 ;
6984 PyObject * obj1 = 0 ;
6985 char *kwnames[] = {
6986 (char *) "self",(char *) "pt", NULL
6987 };
6988
6989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsPoint",kwnames,&obj0,&obj1)) goto fail;
6990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6991 if (SWIG_arg_fail(1)) SWIG_fail;
6992 {
6993 arg2 = &temp2;
6994 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6995 }
6996 {
6997 PyThreadState* __tstate = wxPyBeginAllowThreads();
6998 result = (wxRegionContain)(arg1)->Contains((wxPoint const &)*arg2);
6999
7000 wxPyEndAllowThreads(__tstate);
7001 if (PyErr_Occurred()) SWIG_fail;
7002 }
7003 resultobj = SWIG_From_int((result));
7004 return resultobj;
7005 fail:
7006 return NULL;
7007 }
7008
7009
7010 static PyObject *_wrap_Region_ContainsRect(PyObject *, PyObject *args, PyObject *kwargs) {
7011 PyObject *resultobj;
7012 wxRegion *arg1 = (wxRegion *) 0 ;
7013 wxRect *arg2 = 0 ;
7014 wxRegionContain result;
7015 wxRect temp2 ;
7016 PyObject * obj0 = 0 ;
7017 PyObject * obj1 = 0 ;
7018 char *kwnames[] = {
7019 (char *) "self",(char *) "rect", NULL
7020 };
7021
7022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsRect",kwnames,&obj0,&obj1)) goto fail;
7023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7024 if (SWIG_arg_fail(1)) SWIG_fail;
7025 {
7026 arg2 = &temp2;
7027 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7028 }
7029 {
7030 PyThreadState* __tstate = wxPyBeginAllowThreads();
7031 result = (wxRegionContain)(arg1)->Contains((wxRect const &)*arg2);
7032
7033 wxPyEndAllowThreads(__tstate);
7034 if (PyErr_Occurred()) SWIG_fail;
7035 }
7036 resultobj = SWIG_From_int((result));
7037 return resultobj;
7038 fail:
7039 return NULL;
7040 }
7041
7042
7043 static PyObject *_wrap_Region_ContainsRectDim(PyObject *, PyObject *args, PyObject *kwargs) {
7044 PyObject *resultobj;
7045 wxRegion *arg1 = (wxRegion *) 0 ;
7046 int arg2 ;
7047 int arg3 ;
7048 int arg4 ;
7049 int arg5 ;
7050 wxRegionContain result;
7051 PyObject * obj0 = 0 ;
7052 PyObject * obj1 = 0 ;
7053 PyObject * obj2 = 0 ;
7054 PyObject * obj3 = 0 ;
7055 PyObject * obj4 = 0 ;
7056 char *kwnames[] = {
7057 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
7058 };
7059
7060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_ContainsRectDim",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7062 if (SWIG_arg_fail(1)) SWIG_fail;
7063 {
7064 arg2 = (int)(SWIG_As_int(obj1));
7065 if (SWIG_arg_fail(2)) SWIG_fail;
7066 }
7067 {
7068 arg3 = (int)(SWIG_As_int(obj2));
7069 if (SWIG_arg_fail(3)) SWIG_fail;
7070 }
7071 {
7072 arg4 = (int)(SWIG_As_int(obj3));
7073 if (SWIG_arg_fail(4)) SWIG_fail;
7074 }
7075 {
7076 arg5 = (int)(SWIG_As_int(obj4));
7077 if (SWIG_arg_fail(5)) SWIG_fail;
7078 }
7079 {
7080 PyThreadState* __tstate = wxPyBeginAllowThreads();
7081 result = (wxRegionContain)(arg1)->Contains(arg2,arg3,arg4,arg5);
7082
7083 wxPyEndAllowThreads(__tstate);
7084 if (PyErr_Occurred()) SWIG_fail;
7085 }
7086 resultobj = SWIG_From_int((result));
7087 return resultobj;
7088 fail:
7089 return NULL;
7090 }
7091
7092
7093 static PyObject *_wrap_Region_GetBox(PyObject *, PyObject *args, PyObject *kwargs) {
7094 PyObject *resultobj;
7095 wxRegion *arg1 = (wxRegion *) 0 ;
7096 wxRect result;
7097 PyObject * obj0 = 0 ;
7098 char *kwnames[] = {
7099 (char *) "self", NULL
7100 };
7101
7102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_GetBox",kwnames,&obj0)) goto fail;
7103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7104 if (SWIG_arg_fail(1)) SWIG_fail;
7105 {
7106 PyThreadState* __tstate = wxPyBeginAllowThreads();
7107 result = (arg1)->GetBox();
7108
7109 wxPyEndAllowThreads(__tstate);
7110 if (PyErr_Occurred()) SWIG_fail;
7111 }
7112 {
7113 wxRect * resultptr;
7114 resultptr = new wxRect((wxRect &)(result));
7115 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
7116 }
7117 return resultobj;
7118 fail:
7119 return NULL;
7120 }
7121
7122
7123 static PyObject *_wrap_Region_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
7124 PyObject *resultobj;
7125 wxRegion *arg1 = (wxRegion *) 0 ;
7126 int arg2 ;
7127 int arg3 ;
7128 int arg4 ;
7129 int arg5 ;
7130 bool result;
7131 PyObject * obj0 = 0 ;
7132 PyObject * obj1 = 0 ;
7133 PyObject * obj2 = 0 ;
7134 PyObject * obj3 = 0 ;
7135 PyObject * obj4 = 0 ;
7136 char *kwnames[] = {
7137 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7138 };
7139
7140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Intersect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7142 if (SWIG_arg_fail(1)) SWIG_fail;
7143 {
7144 arg2 = (int)(SWIG_As_int(obj1));
7145 if (SWIG_arg_fail(2)) SWIG_fail;
7146 }
7147 {
7148 arg3 = (int)(SWIG_As_int(obj2));
7149 if (SWIG_arg_fail(3)) SWIG_fail;
7150 }
7151 {
7152 arg4 = (int)(SWIG_As_int(obj3));
7153 if (SWIG_arg_fail(4)) SWIG_fail;
7154 }
7155 {
7156 arg5 = (int)(SWIG_As_int(obj4));
7157 if (SWIG_arg_fail(5)) SWIG_fail;
7158 }
7159 {
7160 PyThreadState* __tstate = wxPyBeginAllowThreads();
7161 result = (bool)(arg1)->Intersect(arg2,arg3,arg4,arg5);
7162
7163 wxPyEndAllowThreads(__tstate);
7164 if (PyErr_Occurred()) SWIG_fail;
7165 }
7166 {
7167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7168 }
7169 return resultobj;
7170 fail:
7171 return NULL;
7172 }
7173
7174
7175 static PyObject *_wrap_Region_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
7176 PyObject *resultobj;
7177 wxRegion *arg1 = (wxRegion *) 0 ;
7178 wxRect *arg2 = 0 ;
7179 bool result;
7180 wxRect temp2 ;
7181 PyObject * obj0 = 0 ;
7182 PyObject * obj1 = 0 ;
7183 char *kwnames[] = {
7184 (char *) "self",(char *) "rect", NULL
7185 };
7186
7187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRect",kwnames,&obj0,&obj1)) goto fail;
7188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7189 if (SWIG_arg_fail(1)) SWIG_fail;
7190 {
7191 arg2 = &temp2;
7192 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7193 }
7194 {
7195 PyThreadState* __tstate = wxPyBeginAllowThreads();
7196 result = (bool)(arg1)->Intersect((wxRect const &)*arg2);
7197
7198 wxPyEndAllowThreads(__tstate);
7199 if (PyErr_Occurred()) SWIG_fail;
7200 }
7201 {
7202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7203 }
7204 return resultobj;
7205 fail:
7206 return NULL;
7207 }
7208
7209
7210 static PyObject *_wrap_Region_IntersectRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7211 PyObject *resultobj;
7212 wxRegion *arg1 = (wxRegion *) 0 ;
7213 wxRegion *arg2 = 0 ;
7214 bool result;
7215 PyObject * obj0 = 0 ;
7216 PyObject * obj1 = 0 ;
7217 char *kwnames[] = {
7218 (char *) "self",(char *) "region", NULL
7219 };
7220
7221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRegion",kwnames,&obj0,&obj1)) goto fail;
7222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7223 if (SWIG_arg_fail(1)) SWIG_fail;
7224 {
7225 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7226 if (SWIG_arg_fail(2)) SWIG_fail;
7227 if (arg2 == NULL) {
7228 SWIG_null_ref("wxRegion");
7229 }
7230 if (SWIG_arg_fail(2)) SWIG_fail;
7231 }
7232 {
7233 PyThreadState* __tstate = wxPyBeginAllowThreads();
7234 result = (bool)(arg1)->Intersect((wxRegion const &)*arg2);
7235
7236 wxPyEndAllowThreads(__tstate);
7237 if (PyErr_Occurred()) SWIG_fail;
7238 }
7239 {
7240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7241 }
7242 return resultobj;
7243 fail:
7244 return NULL;
7245 }
7246
7247
7248 static PyObject *_wrap_Region_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
7249 PyObject *resultobj;
7250 wxRegion *arg1 = (wxRegion *) 0 ;
7251 bool result;
7252 PyObject * obj0 = 0 ;
7253 char *kwnames[] = {
7254 (char *) "self", NULL
7255 };
7256
7257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_IsEmpty",kwnames,&obj0)) goto fail;
7258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7259 if (SWIG_arg_fail(1)) SWIG_fail;
7260 {
7261 PyThreadState* __tstate = wxPyBeginAllowThreads();
7262 result = (bool)(arg1)->IsEmpty();
7263
7264 wxPyEndAllowThreads(__tstate);
7265 if (PyErr_Occurred()) SWIG_fail;
7266 }
7267 {
7268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7269 }
7270 return resultobj;
7271 fail:
7272 return NULL;
7273 }
7274
7275
7276 static PyObject *_wrap_Region_Union(PyObject *, PyObject *args, PyObject *kwargs) {
7277 PyObject *resultobj;
7278 wxRegion *arg1 = (wxRegion *) 0 ;
7279 int arg2 ;
7280 int arg3 ;
7281 int arg4 ;
7282 int arg5 ;
7283 bool result;
7284 PyObject * obj0 = 0 ;
7285 PyObject * obj1 = 0 ;
7286 PyObject * obj2 = 0 ;
7287 PyObject * obj3 = 0 ;
7288 PyObject * obj4 = 0 ;
7289 char *kwnames[] = {
7290 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7291 };
7292
7293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Union",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7295 if (SWIG_arg_fail(1)) SWIG_fail;
7296 {
7297 arg2 = (int)(SWIG_As_int(obj1));
7298 if (SWIG_arg_fail(2)) SWIG_fail;
7299 }
7300 {
7301 arg3 = (int)(SWIG_As_int(obj2));
7302 if (SWIG_arg_fail(3)) SWIG_fail;
7303 }
7304 {
7305 arg4 = (int)(SWIG_As_int(obj3));
7306 if (SWIG_arg_fail(4)) SWIG_fail;
7307 }
7308 {
7309 arg5 = (int)(SWIG_As_int(obj4));
7310 if (SWIG_arg_fail(5)) SWIG_fail;
7311 }
7312 {
7313 PyThreadState* __tstate = wxPyBeginAllowThreads();
7314 result = (bool)(arg1)->Union(arg2,arg3,arg4,arg5);
7315
7316 wxPyEndAllowThreads(__tstate);
7317 if (PyErr_Occurred()) SWIG_fail;
7318 }
7319 {
7320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7321 }
7322 return resultobj;
7323 fail:
7324 return NULL;
7325 }
7326
7327
7328 static PyObject *_wrap_Region_UnionRect(PyObject *, PyObject *args, PyObject *kwargs) {
7329 PyObject *resultobj;
7330 wxRegion *arg1 = (wxRegion *) 0 ;
7331 wxRect *arg2 = 0 ;
7332 bool result;
7333 wxRect temp2 ;
7334 PyObject * obj0 = 0 ;
7335 PyObject * obj1 = 0 ;
7336 char *kwnames[] = {
7337 (char *) "self",(char *) "rect", NULL
7338 };
7339
7340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRect",kwnames,&obj0,&obj1)) goto fail;
7341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7342 if (SWIG_arg_fail(1)) SWIG_fail;
7343 {
7344 arg2 = &temp2;
7345 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7346 }
7347 {
7348 PyThreadState* __tstate = wxPyBeginAllowThreads();
7349 result = (bool)(arg1)->Union((wxRect const &)*arg2);
7350
7351 wxPyEndAllowThreads(__tstate);
7352 if (PyErr_Occurred()) SWIG_fail;
7353 }
7354 {
7355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7356 }
7357 return resultobj;
7358 fail:
7359 return NULL;
7360 }
7361
7362
7363 static PyObject *_wrap_Region_UnionRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7364 PyObject *resultobj;
7365 wxRegion *arg1 = (wxRegion *) 0 ;
7366 wxRegion *arg2 = 0 ;
7367 bool result;
7368 PyObject * obj0 = 0 ;
7369 PyObject * obj1 = 0 ;
7370 char *kwnames[] = {
7371 (char *) "self",(char *) "region", NULL
7372 };
7373
7374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRegion",kwnames,&obj0,&obj1)) goto fail;
7375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7376 if (SWIG_arg_fail(1)) SWIG_fail;
7377 {
7378 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7379 if (SWIG_arg_fail(2)) SWIG_fail;
7380 if (arg2 == NULL) {
7381 SWIG_null_ref("wxRegion");
7382 }
7383 if (SWIG_arg_fail(2)) SWIG_fail;
7384 }
7385 {
7386 PyThreadState* __tstate = wxPyBeginAllowThreads();
7387 result = (bool)(arg1)->Union((wxRegion const &)*arg2);
7388
7389 wxPyEndAllowThreads(__tstate);
7390 if (PyErr_Occurred()) SWIG_fail;
7391 }
7392 {
7393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7394 }
7395 return resultobj;
7396 fail:
7397 return NULL;
7398 }
7399
7400
7401 static PyObject *_wrap_Region_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
7402 PyObject *resultobj;
7403 wxRegion *arg1 = (wxRegion *) 0 ;
7404 int arg2 ;
7405 int arg3 ;
7406 int arg4 ;
7407 int arg5 ;
7408 bool result;
7409 PyObject * obj0 = 0 ;
7410 PyObject * obj1 = 0 ;
7411 PyObject * obj2 = 0 ;
7412 PyObject * obj3 = 0 ;
7413 PyObject * obj4 = 0 ;
7414 char *kwnames[] = {
7415 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7416 };
7417
7418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Subtract",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7420 if (SWIG_arg_fail(1)) SWIG_fail;
7421 {
7422 arg2 = (int)(SWIG_As_int(obj1));
7423 if (SWIG_arg_fail(2)) SWIG_fail;
7424 }
7425 {
7426 arg3 = (int)(SWIG_As_int(obj2));
7427 if (SWIG_arg_fail(3)) SWIG_fail;
7428 }
7429 {
7430 arg4 = (int)(SWIG_As_int(obj3));
7431 if (SWIG_arg_fail(4)) SWIG_fail;
7432 }
7433 {
7434 arg5 = (int)(SWIG_As_int(obj4));
7435 if (SWIG_arg_fail(5)) SWIG_fail;
7436 }
7437 {
7438 PyThreadState* __tstate = wxPyBeginAllowThreads();
7439 result = (bool)(arg1)->Subtract(arg2,arg3,arg4,arg5);
7440
7441 wxPyEndAllowThreads(__tstate);
7442 if (PyErr_Occurred()) SWIG_fail;
7443 }
7444 {
7445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7446 }
7447 return resultobj;
7448 fail:
7449 return NULL;
7450 }
7451
7452
7453 static PyObject *_wrap_Region_SubtractRect(PyObject *, PyObject *args, PyObject *kwargs) {
7454 PyObject *resultobj;
7455 wxRegion *arg1 = (wxRegion *) 0 ;
7456 wxRect *arg2 = 0 ;
7457 bool result;
7458 wxRect temp2 ;
7459 PyObject * obj0 = 0 ;
7460 PyObject * obj1 = 0 ;
7461 char *kwnames[] = {
7462 (char *) "self",(char *) "rect", NULL
7463 };
7464
7465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRect",kwnames,&obj0,&obj1)) goto fail;
7466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7467 if (SWIG_arg_fail(1)) SWIG_fail;
7468 {
7469 arg2 = &temp2;
7470 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7471 }
7472 {
7473 PyThreadState* __tstate = wxPyBeginAllowThreads();
7474 result = (bool)(arg1)->Subtract((wxRect const &)*arg2);
7475
7476 wxPyEndAllowThreads(__tstate);
7477 if (PyErr_Occurred()) SWIG_fail;
7478 }
7479 {
7480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7481 }
7482 return resultobj;
7483 fail:
7484 return NULL;
7485 }
7486
7487
7488 static PyObject *_wrap_Region_SubtractRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7489 PyObject *resultobj;
7490 wxRegion *arg1 = (wxRegion *) 0 ;
7491 wxRegion *arg2 = 0 ;
7492 bool result;
7493 PyObject * obj0 = 0 ;
7494 PyObject * obj1 = 0 ;
7495 char *kwnames[] = {
7496 (char *) "self",(char *) "region", NULL
7497 };
7498
7499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRegion",kwnames,&obj0,&obj1)) goto fail;
7500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7501 if (SWIG_arg_fail(1)) SWIG_fail;
7502 {
7503 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7504 if (SWIG_arg_fail(2)) SWIG_fail;
7505 if (arg2 == NULL) {
7506 SWIG_null_ref("wxRegion");
7507 }
7508 if (SWIG_arg_fail(2)) SWIG_fail;
7509 }
7510 {
7511 PyThreadState* __tstate = wxPyBeginAllowThreads();
7512 result = (bool)(arg1)->Subtract((wxRegion const &)*arg2);
7513
7514 wxPyEndAllowThreads(__tstate);
7515 if (PyErr_Occurred()) SWIG_fail;
7516 }
7517 {
7518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7519 }
7520 return resultobj;
7521 fail:
7522 return NULL;
7523 }
7524
7525
7526 static PyObject *_wrap_Region_Xor(PyObject *, PyObject *args, PyObject *kwargs) {
7527 PyObject *resultobj;
7528 wxRegion *arg1 = (wxRegion *) 0 ;
7529 int arg2 ;
7530 int arg3 ;
7531 int arg4 ;
7532 int arg5 ;
7533 bool result;
7534 PyObject * obj0 = 0 ;
7535 PyObject * obj1 = 0 ;
7536 PyObject * obj2 = 0 ;
7537 PyObject * obj3 = 0 ;
7538 PyObject * obj4 = 0 ;
7539 char *kwnames[] = {
7540 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7541 };
7542
7543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Xor",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7545 if (SWIG_arg_fail(1)) SWIG_fail;
7546 {
7547 arg2 = (int)(SWIG_As_int(obj1));
7548 if (SWIG_arg_fail(2)) SWIG_fail;
7549 }
7550 {
7551 arg3 = (int)(SWIG_As_int(obj2));
7552 if (SWIG_arg_fail(3)) SWIG_fail;
7553 }
7554 {
7555 arg4 = (int)(SWIG_As_int(obj3));
7556 if (SWIG_arg_fail(4)) SWIG_fail;
7557 }
7558 {
7559 arg5 = (int)(SWIG_As_int(obj4));
7560 if (SWIG_arg_fail(5)) SWIG_fail;
7561 }
7562 {
7563 PyThreadState* __tstate = wxPyBeginAllowThreads();
7564 result = (bool)(arg1)->Xor(arg2,arg3,arg4,arg5);
7565
7566 wxPyEndAllowThreads(__tstate);
7567 if (PyErr_Occurred()) SWIG_fail;
7568 }
7569 {
7570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7571 }
7572 return resultobj;
7573 fail:
7574 return NULL;
7575 }
7576
7577
7578 static PyObject *_wrap_Region_XorRect(PyObject *, PyObject *args, PyObject *kwargs) {
7579 PyObject *resultobj;
7580 wxRegion *arg1 = (wxRegion *) 0 ;
7581 wxRect *arg2 = 0 ;
7582 bool result;
7583 wxRect temp2 ;
7584 PyObject * obj0 = 0 ;
7585 PyObject * obj1 = 0 ;
7586 char *kwnames[] = {
7587 (char *) "self",(char *) "rect", NULL
7588 };
7589
7590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRect",kwnames,&obj0,&obj1)) goto fail;
7591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7592 if (SWIG_arg_fail(1)) SWIG_fail;
7593 {
7594 arg2 = &temp2;
7595 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7596 }
7597 {
7598 PyThreadState* __tstate = wxPyBeginAllowThreads();
7599 result = (bool)(arg1)->Xor((wxRect const &)*arg2);
7600
7601 wxPyEndAllowThreads(__tstate);
7602 if (PyErr_Occurred()) SWIG_fail;
7603 }
7604 {
7605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7606 }
7607 return resultobj;
7608 fail:
7609 return NULL;
7610 }
7611
7612
7613 static PyObject *_wrap_Region_XorRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7614 PyObject *resultobj;
7615 wxRegion *arg1 = (wxRegion *) 0 ;
7616 wxRegion *arg2 = 0 ;
7617 bool result;
7618 PyObject * obj0 = 0 ;
7619 PyObject * obj1 = 0 ;
7620 char *kwnames[] = {
7621 (char *) "self",(char *) "region", NULL
7622 };
7623
7624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRegion",kwnames,&obj0,&obj1)) goto fail;
7625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7626 if (SWIG_arg_fail(1)) SWIG_fail;
7627 {
7628 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7629 if (SWIG_arg_fail(2)) SWIG_fail;
7630 if (arg2 == NULL) {
7631 SWIG_null_ref("wxRegion");
7632 }
7633 if (SWIG_arg_fail(2)) SWIG_fail;
7634 }
7635 {
7636 PyThreadState* __tstate = wxPyBeginAllowThreads();
7637 result = (bool)(arg1)->Xor((wxRegion const &)*arg2);
7638
7639 wxPyEndAllowThreads(__tstate);
7640 if (PyErr_Occurred()) SWIG_fail;
7641 }
7642 {
7643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7644 }
7645 return resultobj;
7646 fail:
7647 return NULL;
7648 }
7649
7650
7651 static PyObject *_wrap_Region_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7652 PyObject *resultobj;
7653 wxRegion *arg1 = (wxRegion *) 0 ;
7654 SwigValueWrapper<wxBitmap > result;
7655 PyObject * obj0 = 0 ;
7656 char *kwnames[] = {
7657 (char *) "self", NULL
7658 };
7659
7660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_ConvertToBitmap",kwnames,&obj0)) goto fail;
7661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7662 if (SWIG_arg_fail(1)) SWIG_fail;
7663 {
7664 PyThreadState* __tstate = wxPyBeginAllowThreads();
7665 result = (arg1)->ConvertToBitmap();
7666
7667 wxPyEndAllowThreads(__tstate);
7668 if (PyErr_Occurred()) SWIG_fail;
7669 }
7670 {
7671 wxBitmap * resultptr;
7672 resultptr = new wxBitmap((wxBitmap &)(result));
7673 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
7674 }
7675 return resultobj;
7676 fail:
7677 return NULL;
7678 }
7679
7680
7681 static PyObject *_wrap_Region_UnionBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7682 PyObject *resultobj;
7683 wxRegion *arg1 = (wxRegion *) 0 ;
7684 wxBitmap *arg2 = 0 ;
7685 bool result;
7686 PyObject * obj0 = 0 ;
7687 PyObject * obj1 = 0 ;
7688 char *kwnames[] = {
7689 (char *) "self",(char *) "bmp", NULL
7690 };
7691
7692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionBitmap",kwnames,&obj0,&obj1)) goto fail;
7693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7694 if (SWIG_arg_fail(1)) SWIG_fail;
7695 {
7696 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7697 if (SWIG_arg_fail(2)) SWIG_fail;
7698 if (arg2 == NULL) {
7699 SWIG_null_ref("wxBitmap");
7700 }
7701 if (SWIG_arg_fail(2)) SWIG_fail;
7702 }
7703 {
7704 PyThreadState* __tstate = wxPyBeginAllowThreads();
7705 result = (bool)(arg1)->Union((wxBitmap const &)*arg2);
7706
7707 wxPyEndAllowThreads(__tstate);
7708 if (PyErr_Occurred()) SWIG_fail;
7709 }
7710 {
7711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7712 }
7713 return resultobj;
7714 fail:
7715 return NULL;
7716 }
7717
7718
7719 static PyObject *_wrap_Region_UnionBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
7720 PyObject *resultobj;
7721 wxRegion *arg1 = (wxRegion *) 0 ;
7722 wxBitmap *arg2 = 0 ;
7723 wxColour *arg3 = 0 ;
7724 int arg4 = (int) 0 ;
7725 bool result;
7726 wxColour temp3 ;
7727 PyObject * obj0 = 0 ;
7728 PyObject * obj1 = 0 ;
7729 PyObject * obj2 = 0 ;
7730 PyObject * obj3 = 0 ;
7731 char *kwnames[] = {
7732 (char *) "self",(char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
7733 };
7734
7735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Region_UnionBitmapColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7737 if (SWIG_arg_fail(1)) SWIG_fail;
7738 {
7739 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7740 if (SWIG_arg_fail(2)) SWIG_fail;
7741 if (arg2 == NULL) {
7742 SWIG_null_ref("wxBitmap");
7743 }
7744 if (SWIG_arg_fail(2)) SWIG_fail;
7745 }
7746 {
7747 arg3 = &temp3;
7748 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
7749 }
7750 if (obj3) {
7751 {
7752 arg4 = (int)(SWIG_As_int(obj3));
7753 if (SWIG_arg_fail(4)) SWIG_fail;
7754 }
7755 }
7756 {
7757 PyThreadState* __tstate = wxPyBeginAllowThreads();
7758 result = (bool)(arg1)->Union((wxBitmap const &)*arg2,(wxColour const &)*arg3,arg4);
7759
7760 wxPyEndAllowThreads(__tstate);
7761 if (PyErr_Occurred()) SWIG_fail;
7762 }
7763 {
7764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7765 }
7766 return resultobj;
7767 fail:
7768 return NULL;
7769 }
7770
7771
7772 static PyObject * Region_swigregister(PyObject *, PyObject *args) {
7773 PyObject *obj;
7774 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7775 SWIG_TypeClientData(SWIGTYPE_p_wxRegion, obj);
7776 Py_INCREF(obj);
7777 return Py_BuildValue((char *)"");
7778 }
7779 static PyObject *_wrap_new_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7780 PyObject *resultobj;
7781 wxRegion *arg1 = 0 ;
7782 wxRegionIterator *result;
7783 PyObject * obj0 = 0 ;
7784 char *kwnames[] = {
7785 (char *) "region", NULL
7786 };
7787
7788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionIterator",kwnames,&obj0)) goto fail;
7789 {
7790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7791 if (SWIG_arg_fail(1)) SWIG_fail;
7792 if (arg1 == NULL) {
7793 SWIG_null_ref("wxRegion");
7794 }
7795 if (SWIG_arg_fail(1)) SWIG_fail;
7796 }
7797 {
7798 if (!wxPyCheckForApp()) SWIG_fail;
7799 PyThreadState* __tstate = wxPyBeginAllowThreads();
7800 result = (wxRegionIterator *)new wxRegionIterator((wxRegion const &)*arg1);
7801
7802 wxPyEndAllowThreads(__tstate);
7803 if (PyErr_Occurred()) SWIG_fail;
7804 }
7805 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegionIterator, 1);
7806 return resultobj;
7807 fail:
7808 return NULL;
7809 }
7810
7811
7812 static PyObject *_wrap_delete_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7813 PyObject *resultobj;
7814 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7815 PyObject * obj0 = 0 ;
7816 char *kwnames[] = {
7817 (char *) "self", NULL
7818 };
7819
7820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RegionIterator",kwnames,&obj0)) goto fail;
7821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7822 if (SWIG_arg_fail(1)) SWIG_fail;
7823 {
7824 PyThreadState* __tstate = wxPyBeginAllowThreads();
7825 delete arg1;
7826
7827 wxPyEndAllowThreads(__tstate);
7828 if (PyErr_Occurred()) SWIG_fail;
7829 }
7830 Py_INCREF(Py_None); resultobj = Py_None;
7831 return resultobj;
7832 fail:
7833 return NULL;
7834 }
7835
7836
7837 static PyObject *_wrap_RegionIterator_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
7838 PyObject *resultobj;
7839 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7840 int result;
7841 PyObject * obj0 = 0 ;
7842 char *kwnames[] = {
7843 (char *) "self", NULL
7844 };
7845
7846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetX",kwnames,&obj0)) goto fail;
7847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7848 if (SWIG_arg_fail(1)) SWIG_fail;
7849 {
7850 PyThreadState* __tstate = wxPyBeginAllowThreads();
7851 result = (int)(arg1)->GetX();
7852
7853 wxPyEndAllowThreads(__tstate);
7854 if (PyErr_Occurred()) SWIG_fail;
7855 }
7856 {
7857 resultobj = SWIG_From_int((int)(result));
7858 }
7859 return resultobj;
7860 fail:
7861 return NULL;
7862 }
7863
7864
7865 static PyObject *_wrap_RegionIterator_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
7866 PyObject *resultobj;
7867 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7868 int result;
7869 PyObject * obj0 = 0 ;
7870 char *kwnames[] = {
7871 (char *) "self", NULL
7872 };
7873
7874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetY",kwnames,&obj0)) goto fail;
7875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7876 if (SWIG_arg_fail(1)) SWIG_fail;
7877 {
7878 PyThreadState* __tstate = wxPyBeginAllowThreads();
7879 result = (int)(arg1)->GetY();
7880
7881 wxPyEndAllowThreads(__tstate);
7882 if (PyErr_Occurred()) SWIG_fail;
7883 }
7884 {
7885 resultobj = SWIG_From_int((int)(result));
7886 }
7887 return resultobj;
7888 fail:
7889 return NULL;
7890 }
7891
7892
7893 static PyObject *_wrap_RegionIterator_GetW(PyObject *, PyObject *args, PyObject *kwargs) {
7894 PyObject *resultobj;
7895 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7896 int result;
7897 PyObject * obj0 = 0 ;
7898 char *kwnames[] = {
7899 (char *) "self", NULL
7900 };
7901
7902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetW",kwnames,&obj0)) goto fail;
7903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7904 if (SWIG_arg_fail(1)) SWIG_fail;
7905 {
7906 PyThreadState* __tstate = wxPyBeginAllowThreads();
7907 result = (int)(arg1)->GetW();
7908
7909 wxPyEndAllowThreads(__tstate);
7910 if (PyErr_Occurred()) SWIG_fail;
7911 }
7912 {
7913 resultobj = SWIG_From_int((int)(result));
7914 }
7915 return resultobj;
7916 fail:
7917 return NULL;
7918 }
7919
7920
7921 static PyObject *_wrap_RegionIterator_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
7922 PyObject *resultobj;
7923 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7924 int result;
7925 PyObject * obj0 = 0 ;
7926 char *kwnames[] = {
7927 (char *) "self", NULL
7928 };
7929
7930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetWidth",kwnames,&obj0)) goto fail;
7931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7932 if (SWIG_arg_fail(1)) SWIG_fail;
7933 {
7934 PyThreadState* __tstate = wxPyBeginAllowThreads();
7935 result = (int)(arg1)->GetWidth();
7936
7937 wxPyEndAllowThreads(__tstate);
7938 if (PyErr_Occurred()) SWIG_fail;
7939 }
7940 {
7941 resultobj = SWIG_From_int((int)(result));
7942 }
7943 return resultobj;
7944 fail:
7945 return NULL;
7946 }
7947
7948
7949 static PyObject *_wrap_RegionIterator_GetH(PyObject *, PyObject *args, PyObject *kwargs) {
7950 PyObject *resultobj;
7951 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7952 int result;
7953 PyObject * obj0 = 0 ;
7954 char *kwnames[] = {
7955 (char *) "self", NULL
7956 };
7957
7958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetH",kwnames,&obj0)) goto fail;
7959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7960 if (SWIG_arg_fail(1)) SWIG_fail;
7961 {
7962 PyThreadState* __tstate = wxPyBeginAllowThreads();
7963 result = (int)(arg1)->GetH();
7964
7965 wxPyEndAllowThreads(__tstate);
7966 if (PyErr_Occurred()) SWIG_fail;
7967 }
7968 {
7969 resultobj = SWIG_From_int((int)(result));
7970 }
7971 return resultobj;
7972 fail:
7973 return NULL;
7974 }
7975
7976
7977 static PyObject *_wrap_RegionIterator_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
7978 PyObject *resultobj;
7979 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7980 int result;
7981 PyObject * obj0 = 0 ;
7982 char *kwnames[] = {
7983 (char *) "self", NULL
7984 };
7985
7986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetHeight",kwnames,&obj0)) goto fail;
7987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7988 if (SWIG_arg_fail(1)) SWIG_fail;
7989 {
7990 PyThreadState* __tstate = wxPyBeginAllowThreads();
7991 result = (int)(arg1)->GetHeight();
7992
7993 wxPyEndAllowThreads(__tstate);
7994 if (PyErr_Occurred()) SWIG_fail;
7995 }
7996 {
7997 resultobj = SWIG_From_int((int)(result));
7998 }
7999 return resultobj;
8000 fail:
8001 return NULL;
8002 }
8003
8004
8005 static PyObject *_wrap_RegionIterator_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
8006 PyObject *resultobj;
8007 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8008 wxRect result;
8009 PyObject * obj0 = 0 ;
8010 char *kwnames[] = {
8011 (char *) "self", NULL
8012 };
8013
8014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetRect",kwnames,&obj0)) goto fail;
8015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8016 if (SWIG_arg_fail(1)) SWIG_fail;
8017 {
8018 PyThreadState* __tstate = wxPyBeginAllowThreads();
8019 result = (arg1)->GetRect();
8020
8021 wxPyEndAllowThreads(__tstate);
8022 if (PyErr_Occurred()) SWIG_fail;
8023 }
8024 {
8025 wxRect * resultptr;
8026 resultptr = new wxRect((wxRect &)(result));
8027 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
8028 }
8029 return resultobj;
8030 fail:
8031 return NULL;
8032 }
8033
8034
8035 static PyObject *_wrap_RegionIterator_HaveRects(PyObject *, PyObject *args, PyObject *kwargs) {
8036 PyObject *resultobj;
8037 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8038 bool result;
8039 PyObject * obj0 = 0 ;
8040 char *kwnames[] = {
8041 (char *) "self", NULL
8042 };
8043
8044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_HaveRects",kwnames,&obj0)) goto fail;
8045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8046 if (SWIG_arg_fail(1)) SWIG_fail;
8047 {
8048 PyThreadState* __tstate = wxPyBeginAllowThreads();
8049 result = (bool)(arg1)->HaveRects();
8050
8051 wxPyEndAllowThreads(__tstate);
8052 if (PyErr_Occurred()) SWIG_fail;
8053 }
8054 {
8055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8056 }
8057 return resultobj;
8058 fail:
8059 return NULL;
8060 }
8061
8062
8063 static PyObject *_wrap_RegionIterator_Reset(PyObject *, PyObject *args, PyObject *kwargs) {
8064 PyObject *resultobj;
8065 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8066 PyObject * obj0 = 0 ;
8067 char *kwnames[] = {
8068 (char *) "self", NULL
8069 };
8070
8071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Reset",kwnames,&obj0)) goto fail;
8072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8073 if (SWIG_arg_fail(1)) SWIG_fail;
8074 {
8075 PyThreadState* __tstate = wxPyBeginAllowThreads();
8076 (arg1)->Reset();
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_RegionIterator_Next(PyObject *, PyObject *args, PyObject *kwargs) {
8089 PyObject *resultobj;
8090 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8091 PyObject * obj0 = 0 ;
8092 char *kwnames[] = {
8093 (char *) "self", NULL
8094 };
8095
8096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Next",kwnames,&obj0)) goto fail;
8097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8098 if (SWIG_arg_fail(1)) SWIG_fail;
8099 {
8100 PyThreadState* __tstate = wxPyBeginAllowThreads();
8101 wxRegionIterator_Next(arg1);
8102
8103 wxPyEndAllowThreads(__tstate);
8104 if (PyErr_Occurred()) SWIG_fail;
8105 }
8106 Py_INCREF(Py_None); resultobj = Py_None;
8107 return resultobj;
8108 fail:
8109 return NULL;
8110 }
8111
8112
8113 static PyObject *_wrap_RegionIterator___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
8114 PyObject *resultobj;
8115 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8116 bool result;
8117 PyObject * obj0 = 0 ;
8118 char *kwnames[] = {
8119 (char *) "self", NULL
8120 };
8121
8122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator___nonzero__",kwnames,&obj0)) goto fail;
8123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8124 if (SWIG_arg_fail(1)) SWIG_fail;
8125 {
8126 PyThreadState* __tstate = wxPyBeginAllowThreads();
8127 result = (bool)wxRegionIterator___nonzero__(arg1);
8128
8129 wxPyEndAllowThreads(__tstate);
8130 if (PyErr_Occurred()) SWIG_fail;
8131 }
8132 {
8133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8134 }
8135 return resultobj;
8136 fail:
8137 return NULL;
8138 }
8139
8140
8141 static PyObject * RegionIterator_swigregister(PyObject *, PyObject *args) {
8142 PyObject *obj;
8143 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8144 SWIG_TypeClientData(SWIGTYPE_p_wxRegionIterator, obj);
8145 Py_INCREF(obj);
8146 return Py_BuildValue((char *)"");
8147 }
8148 static PyObject *_wrap_new_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8149 PyObject *resultobj;
8150 wxNativeFontInfo *result;
8151 char *kwnames[] = {
8152 NULL
8153 };
8154
8155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeFontInfo",kwnames)) goto fail;
8156 {
8157 PyThreadState* __tstate = wxPyBeginAllowThreads();
8158 result = (wxNativeFontInfo *)new wxNativeFontInfo();
8159
8160 wxPyEndAllowThreads(__tstate);
8161 if (PyErr_Occurred()) SWIG_fail;
8162 }
8163 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 1);
8164 return resultobj;
8165 fail:
8166 return NULL;
8167 }
8168
8169
8170 static PyObject *_wrap_delete_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8171 PyObject *resultobj;
8172 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8173 PyObject * obj0 = 0 ;
8174 char *kwnames[] = {
8175 (char *) "self", NULL
8176 };
8177
8178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeFontInfo",kwnames,&obj0)) goto fail;
8179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8180 if (SWIG_arg_fail(1)) SWIG_fail;
8181 {
8182 PyThreadState* __tstate = wxPyBeginAllowThreads();
8183 delete arg1;
8184
8185 wxPyEndAllowThreads(__tstate);
8186 if (PyErr_Occurred()) SWIG_fail;
8187 }
8188 Py_INCREF(Py_None); resultobj = Py_None;
8189 return resultobj;
8190 fail:
8191 return NULL;
8192 }
8193
8194
8195 static PyObject *_wrap_NativeFontInfo_Init(PyObject *, PyObject *args, PyObject *kwargs) {
8196 PyObject *resultobj;
8197 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8198 PyObject * obj0 = 0 ;
8199 char *kwnames[] = {
8200 (char *) "self", NULL
8201 };
8202
8203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_Init",kwnames,&obj0)) goto fail;
8204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8205 if (SWIG_arg_fail(1)) SWIG_fail;
8206 {
8207 PyThreadState* __tstate = wxPyBeginAllowThreads();
8208 (arg1)->Init();
8209
8210 wxPyEndAllowThreads(__tstate);
8211 if (PyErr_Occurred()) SWIG_fail;
8212 }
8213 Py_INCREF(Py_None); resultobj = Py_None;
8214 return resultobj;
8215 fail:
8216 return NULL;
8217 }
8218
8219
8220 static PyObject *_wrap_NativeFontInfo_InitFromFont(PyObject *, PyObject *args, PyObject *kwargs) {
8221 PyObject *resultobj;
8222 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8223 wxFont *arg2 = 0 ;
8224 PyObject * obj0 = 0 ;
8225 PyObject * obj1 = 0 ;
8226 char *kwnames[] = {
8227 (char *) "self",(char *) "font", NULL
8228 };
8229
8230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_InitFromFont",kwnames,&obj0,&obj1)) goto fail;
8231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8232 if (SWIG_arg_fail(1)) SWIG_fail;
8233 {
8234 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
8235 if (SWIG_arg_fail(2)) SWIG_fail;
8236 if (arg2 == NULL) {
8237 SWIG_null_ref("wxFont");
8238 }
8239 if (SWIG_arg_fail(2)) SWIG_fail;
8240 }
8241 {
8242 PyThreadState* __tstate = wxPyBeginAllowThreads();
8243 (arg1)->InitFromFont((wxFont const &)*arg2);
8244
8245 wxPyEndAllowThreads(__tstate);
8246 if (PyErr_Occurred()) SWIG_fail;
8247 }
8248 Py_INCREF(Py_None); resultobj = Py_None;
8249 return resultobj;
8250 fail:
8251 return NULL;
8252 }
8253
8254
8255 static PyObject *_wrap_NativeFontInfo_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
8256 PyObject *resultobj;
8257 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8258 int result;
8259 PyObject * obj0 = 0 ;
8260 char *kwnames[] = {
8261 (char *) "self", NULL
8262 };
8263
8264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetPointSize",kwnames,&obj0)) goto fail;
8265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8266 if (SWIG_arg_fail(1)) SWIG_fail;
8267 {
8268 PyThreadState* __tstate = wxPyBeginAllowThreads();
8269 result = (int)((wxNativeFontInfo const *)arg1)->GetPointSize();
8270
8271 wxPyEndAllowThreads(__tstate);
8272 if (PyErr_Occurred()) SWIG_fail;
8273 }
8274 {
8275 resultobj = SWIG_From_int((int)(result));
8276 }
8277 return resultobj;
8278 fail:
8279 return NULL;
8280 }
8281
8282
8283 static PyObject *_wrap_NativeFontInfo_GetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
8284 PyObject *resultobj;
8285 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8286 wxSize result;
8287 PyObject * obj0 = 0 ;
8288 char *kwnames[] = {
8289 (char *) "self", NULL
8290 };
8291
8292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetPixelSize",kwnames,&obj0)) goto fail;
8293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8294 if (SWIG_arg_fail(1)) SWIG_fail;
8295 {
8296 PyThreadState* __tstate = wxPyBeginAllowThreads();
8297 result = ((wxNativeFontInfo const *)arg1)->GetPixelSize();
8298
8299 wxPyEndAllowThreads(__tstate);
8300 if (PyErr_Occurred()) SWIG_fail;
8301 }
8302 {
8303 wxSize * resultptr;
8304 resultptr = new wxSize((wxSize &)(result));
8305 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
8306 }
8307 return resultobj;
8308 fail:
8309 return NULL;
8310 }
8311
8312
8313 static PyObject *_wrap_NativeFontInfo_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
8314 PyObject *resultobj;
8315 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8316 wxFontStyle result;
8317 PyObject * obj0 = 0 ;
8318 char *kwnames[] = {
8319 (char *) "self", NULL
8320 };
8321
8322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetStyle",kwnames,&obj0)) goto fail;
8323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8324 if (SWIG_arg_fail(1)) SWIG_fail;
8325 {
8326 PyThreadState* __tstate = wxPyBeginAllowThreads();
8327 result = (wxFontStyle)((wxNativeFontInfo const *)arg1)->GetStyle();
8328
8329 wxPyEndAllowThreads(__tstate);
8330 if (PyErr_Occurred()) SWIG_fail;
8331 }
8332 resultobj = SWIG_From_int((result));
8333 return resultobj;
8334 fail:
8335 return NULL;
8336 }
8337
8338
8339 static PyObject *_wrap_NativeFontInfo_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
8340 PyObject *resultobj;
8341 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8342 wxFontWeight result;
8343 PyObject * obj0 = 0 ;
8344 char *kwnames[] = {
8345 (char *) "self", NULL
8346 };
8347
8348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetWeight",kwnames,&obj0)) goto fail;
8349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8350 if (SWIG_arg_fail(1)) SWIG_fail;
8351 {
8352 PyThreadState* __tstate = wxPyBeginAllowThreads();
8353 result = (wxFontWeight)((wxNativeFontInfo const *)arg1)->GetWeight();
8354
8355 wxPyEndAllowThreads(__tstate);
8356 if (PyErr_Occurred()) SWIG_fail;
8357 }
8358 resultobj = SWIG_From_int((result));
8359 return resultobj;
8360 fail:
8361 return NULL;
8362 }
8363
8364
8365 static PyObject *_wrap_NativeFontInfo_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
8366 PyObject *resultobj;
8367 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8368 bool result;
8369 PyObject * obj0 = 0 ;
8370 char *kwnames[] = {
8371 (char *) "self", NULL
8372 };
8373
8374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetUnderlined",kwnames,&obj0)) goto fail;
8375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8376 if (SWIG_arg_fail(1)) SWIG_fail;
8377 {
8378 PyThreadState* __tstate = wxPyBeginAllowThreads();
8379 result = (bool)((wxNativeFontInfo const *)arg1)->GetUnderlined();
8380
8381 wxPyEndAllowThreads(__tstate);
8382 if (PyErr_Occurred()) SWIG_fail;
8383 }
8384 {
8385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8386 }
8387 return resultobj;
8388 fail:
8389 return NULL;
8390 }
8391
8392
8393 static PyObject *_wrap_NativeFontInfo_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
8394 PyObject *resultobj;
8395 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8396 wxString result;
8397 PyObject * obj0 = 0 ;
8398 char *kwnames[] = {
8399 (char *) "self", NULL
8400 };
8401
8402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFaceName",kwnames,&obj0)) goto fail;
8403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8404 if (SWIG_arg_fail(1)) SWIG_fail;
8405 {
8406 PyThreadState* __tstate = wxPyBeginAllowThreads();
8407 result = ((wxNativeFontInfo const *)arg1)->GetFaceName();
8408
8409 wxPyEndAllowThreads(__tstate);
8410 if (PyErr_Occurred()) SWIG_fail;
8411 }
8412 {
8413 #if wxUSE_UNICODE
8414 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8415 #else
8416 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8417 #endif
8418 }
8419 return resultobj;
8420 fail:
8421 return NULL;
8422 }
8423
8424
8425 static PyObject *_wrap_NativeFontInfo_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
8426 PyObject *resultobj;
8427 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8428 wxFontFamily result;
8429 PyObject * obj0 = 0 ;
8430 char *kwnames[] = {
8431 (char *) "self", NULL
8432 };
8433
8434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFamily",kwnames,&obj0)) goto fail;
8435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8436 if (SWIG_arg_fail(1)) SWIG_fail;
8437 {
8438 PyThreadState* __tstate = wxPyBeginAllowThreads();
8439 result = (wxFontFamily)((wxNativeFontInfo const *)arg1)->GetFamily();
8440
8441 wxPyEndAllowThreads(__tstate);
8442 if (PyErr_Occurred()) SWIG_fail;
8443 }
8444 resultobj = SWIG_From_int((result));
8445 return resultobj;
8446 fail:
8447 return NULL;
8448 }
8449
8450
8451 static PyObject *_wrap_NativeFontInfo_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8452 PyObject *resultobj;
8453 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8454 wxFontEncoding result;
8455 PyObject * obj0 = 0 ;
8456 char *kwnames[] = {
8457 (char *) "self", NULL
8458 };
8459
8460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetEncoding",kwnames,&obj0)) goto fail;
8461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8462 if (SWIG_arg_fail(1)) SWIG_fail;
8463 {
8464 PyThreadState* __tstate = wxPyBeginAllowThreads();
8465 result = (wxFontEncoding)((wxNativeFontInfo const *)arg1)->GetEncoding();
8466
8467 wxPyEndAllowThreads(__tstate);
8468 if (PyErr_Occurred()) SWIG_fail;
8469 }
8470 resultobj = SWIG_From_int((result));
8471 return resultobj;
8472 fail:
8473 return NULL;
8474 }
8475
8476
8477 static PyObject *_wrap_NativeFontInfo_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
8478 PyObject *resultobj;
8479 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8480 int arg2 ;
8481 PyObject * obj0 = 0 ;
8482 PyObject * obj1 = 0 ;
8483 char *kwnames[] = {
8484 (char *) "self",(char *) "pointsize", NULL
8485 };
8486
8487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
8488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8489 if (SWIG_arg_fail(1)) SWIG_fail;
8490 {
8491 arg2 = (int)(SWIG_As_int(obj1));
8492 if (SWIG_arg_fail(2)) SWIG_fail;
8493 }
8494 {
8495 PyThreadState* __tstate = wxPyBeginAllowThreads();
8496 (arg1)->SetPointSize(arg2);
8497
8498 wxPyEndAllowThreads(__tstate);
8499 if (PyErr_Occurred()) SWIG_fail;
8500 }
8501 Py_INCREF(Py_None); resultobj = Py_None;
8502 return resultobj;
8503 fail:
8504 return NULL;
8505 }
8506
8507
8508 static PyObject *_wrap_NativeFontInfo_SetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
8509 PyObject *resultobj;
8510 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8511 wxSize *arg2 = 0 ;
8512 wxSize temp2 ;
8513 PyObject * obj0 = 0 ;
8514 PyObject * obj1 = 0 ;
8515 char *kwnames[] = {
8516 (char *) "self",(char *) "pixelSize", NULL
8517 };
8518
8519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPixelSize",kwnames,&obj0,&obj1)) goto fail;
8520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8521 if (SWIG_arg_fail(1)) SWIG_fail;
8522 {
8523 arg2 = &temp2;
8524 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8525 }
8526 {
8527 PyThreadState* __tstate = wxPyBeginAllowThreads();
8528 (arg1)->SetPixelSize((wxSize const &)*arg2);
8529
8530 wxPyEndAllowThreads(__tstate);
8531 if (PyErr_Occurred()) SWIG_fail;
8532 }
8533 Py_INCREF(Py_None); resultobj = Py_None;
8534 return resultobj;
8535 fail:
8536 return NULL;
8537 }
8538
8539
8540 static PyObject *_wrap_NativeFontInfo_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
8541 PyObject *resultobj;
8542 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8543 wxFontStyle arg2 ;
8544 PyObject * obj0 = 0 ;
8545 PyObject * obj1 = 0 ;
8546 char *kwnames[] = {
8547 (char *) "self",(char *) "style", NULL
8548 };
8549
8550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetStyle",kwnames,&obj0,&obj1)) goto fail;
8551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8552 if (SWIG_arg_fail(1)) SWIG_fail;
8553 {
8554 arg2 = (wxFontStyle)(SWIG_As_int(obj1));
8555 if (SWIG_arg_fail(2)) SWIG_fail;
8556 }
8557 {
8558 PyThreadState* __tstate = wxPyBeginAllowThreads();
8559 (arg1)->SetStyle((wxFontStyle )arg2);
8560
8561 wxPyEndAllowThreads(__tstate);
8562 if (PyErr_Occurred()) SWIG_fail;
8563 }
8564 Py_INCREF(Py_None); resultobj = Py_None;
8565 return resultobj;
8566 fail:
8567 return NULL;
8568 }
8569
8570
8571 static PyObject *_wrap_NativeFontInfo_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
8572 PyObject *resultobj;
8573 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8574 wxFontWeight arg2 ;
8575 PyObject * obj0 = 0 ;
8576 PyObject * obj1 = 0 ;
8577 char *kwnames[] = {
8578 (char *) "self",(char *) "weight", NULL
8579 };
8580
8581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetWeight",kwnames,&obj0,&obj1)) goto fail;
8582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8583 if (SWIG_arg_fail(1)) SWIG_fail;
8584 {
8585 arg2 = (wxFontWeight)(SWIG_As_int(obj1));
8586 if (SWIG_arg_fail(2)) SWIG_fail;
8587 }
8588 {
8589 PyThreadState* __tstate = wxPyBeginAllowThreads();
8590 (arg1)->SetWeight((wxFontWeight )arg2);
8591
8592 wxPyEndAllowThreads(__tstate);
8593 if (PyErr_Occurred()) SWIG_fail;
8594 }
8595 Py_INCREF(Py_None); resultobj = Py_None;
8596 return resultobj;
8597 fail:
8598 return NULL;
8599 }
8600
8601
8602 static PyObject *_wrap_NativeFontInfo_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
8603 PyObject *resultobj;
8604 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8605 bool arg2 ;
8606 PyObject * obj0 = 0 ;
8607 PyObject * obj1 = 0 ;
8608 char *kwnames[] = {
8609 (char *) "self",(char *) "underlined", NULL
8610 };
8611
8612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
8613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8614 if (SWIG_arg_fail(1)) SWIG_fail;
8615 {
8616 arg2 = (bool)(SWIG_As_bool(obj1));
8617 if (SWIG_arg_fail(2)) SWIG_fail;
8618 }
8619 {
8620 PyThreadState* __tstate = wxPyBeginAllowThreads();
8621 (arg1)->SetUnderlined(arg2);
8622
8623 wxPyEndAllowThreads(__tstate);
8624 if (PyErr_Occurred()) SWIG_fail;
8625 }
8626 Py_INCREF(Py_None); resultobj = Py_None;
8627 return resultobj;
8628 fail:
8629 return NULL;
8630 }
8631
8632
8633 static PyObject *_wrap_NativeFontInfo_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
8634 PyObject *resultobj;
8635 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8636 wxString arg2 ;
8637 PyObject * obj0 = 0 ;
8638 PyObject * obj1 = 0 ;
8639 char *kwnames[] = {
8640 (char *) "self",(char *) "facename", NULL
8641 };
8642
8643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
8644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8645 if (SWIG_arg_fail(1)) SWIG_fail;
8646 {
8647 wxString* sptr = wxString_in_helper(obj1);
8648 if (sptr == NULL) SWIG_fail;
8649 arg2 = *sptr;
8650 delete sptr;
8651 }
8652 {
8653 PyThreadState* __tstate = wxPyBeginAllowThreads();
8654 (arg1)->SetFaceName(arg2);
8655
8656 wxPyEndAllowThreads(__tstate);
8657 if (PyErr_Occurred()) SWIG_fail;
8658 }
8659 Py_INCREF(Py_None); resultobj = Py_None;
8660 return resultobj;
8661 fail:
8662 return NULL;
8663 }
8664
8665
8666 static PyObject *_wrap_NativeFontInfo_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
8667 PyObject *resultobj;
8668 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8669 wxFontFamily arg2 ;
8670 PyObject * obj0 = 0 ;
8671 PyObject * obj1 = 0 ;
8672 char *kwnames[] = {
8673 (char *) "self",(char *) "family", NULL
8674 };
8675
8676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFamily",kwnames,&obj0,&obj1)) goto fail;
8677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8678 if (SWIG_arg_fail(1)) SWIG_fail;
8679 {
8680 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
8681 if (SWIG_arg_fail(2)) SWIG_fail;
8682 }
8683 {
8684 PyThreadState* __tstate = wxPyBeginAllowThreads();
8685 (arg1)->SetFamily((wxFontFamily )arg2);
8686
8687 wxPyEndAllowThreads(__tstate);
8688 if (PyErr_Occurred()) SWIG_fail;
8689 }
8690 Py_INCREF(Py_None); resultobj = Py_None;
8691 return resultobj;
8692 fail:
8693 return NULL;
8694 }
8695
8696
8697 static PyObject *_wrap_NativeFontInfo_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8698 PyObject *resultobj;
8699 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8700 wxFontEncoding arg2 ;
8701 PyObject * obj0 = 0 ;
8702 PyObject * obj1 = 0 ;
8703 char *kwnames[] = {
8704 (char *) "self",(char *) "encoding", NULL
8705 };
8706
8707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
8708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8709 if (SWIG_arg_fail(1)) SWIG_fail;
8710 {
8711 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8712 if (SWIG_arg_fail(2)) SWIG_fail;
8713 }
8714 {
8715 PyThreadState* __tstate = wxPyBeginAllowThreads();
8716 (arg1)->SetEncoding((wxFontEncoding )arg2);
8717
8718 wxPyEndAllowThreads(__tstate);
8719 if (PyErr_Occurred()) SWIG_fail;
8720 }
8721 Py_INCREF(Py_None); resultobj = Py_None;
8722 return resultobj;
8723 fail:
8724 return NULL;
8725 }
8726
8727
8728 static PyObject *_wrap_NativeFontInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8729 PyObject *resultobj;
8730 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8731 wxString *arg2 = 0 ;
8732 bool result;
8733 bool temp2 = false ;
8734 PyObject * obj0 = 0 ;
8735 PyObject * obj1 = 0 ;
8736 char *kwnames[] = {
8737 (char *) "self",(char *) "s", NULL
8738 };
8739
8740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8742 if (SWIG_arg_fail(1)) SWIG_fail;
8743 {
8744 arg2 = wxString_in_helper(obj1);
8745 if (arg2 == NULL) SWIG_fail;
8746 temp2 = true;
8747 }
8748 {
8749 PyThreadState* __tstate = wxPyBeginAllowThreads();
8750 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8751
8752 wxPyEndAllowThreads(__tstate);
8753 if (PyErr_Occurred()) SWIG_fail;
8754 }
8755 {
8756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8757 }
8758 {
8759 if (temp2)
8760 delete arg2;
8761 }
8762 return resultobj;
8763 fail:
8764 {
8765 if (temp2)
8766 delete arg2;
8767 }
8768 return NULL;
8769 }
8770
8771
8772 static PyObject *_wrap_NativeFontInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8773 PyObject *resultobj;
8774 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8775 wxString result;
8776 PyObject * obj0 = 0 ;
8777 char *kwnames[] = {
8778 (char *) "self", NULL
8779 };
8780
8781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToString",kwnames,&obj0)) goto fail;
8782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8783 if (SWIG_arg_fail(1)) SWIG_fail;
8784 {
8785 PyThreadState* __tstate = wxPyBeginAllowThreads();
8786 result = ((wxNativeFontInfo const *)arg1)->ToString();
8787
8788 wxPyEndAllowThreads(__tstate);
8789 if (PyErr_Occurred()) SWIG_fail;
8790 }
8791 {
8792 #if wxUSE_UNICODE
8793 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8794 #else
8795 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8796 #endif
8797 }
8798 return resultobj;
8799 fail:
8800 return NULL;
8801 }
8802
8803
8804 static PyObject *_wrap_NativeFontInfo___str__(PyObject *, PyObject *args, PyObject *kwargs) {
8805 PyObject *resultobj;
8806 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8807 wxString result;
8808 PyObject * obj0 = 0 ;
8809 char *kwnames[] = {
8810 (char *) "self", NULL
8811 };
8812
8813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo___str__",kwnames,&obj0)) goto fail;
8814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8815 if (SWIG_arg_fail(1)) SWIG_fail;
8816 {
8817 PyThreadState* __tstate = wxPyBeginAllowThreads();
8818 result = wxNativeFontInfo___str__(arg1);
8819
8820 wxPyEndAllowThreads(__tstate);
8821 if (PyErr_Occurred()) SWIG_fail;
8822 }
8823 {
8824 #if wxUSE_UNICODE
8825 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8826 #else
8827 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8828 #endif
8829 }
8830 return resultobj;
8831 fail:
8832 return NULL;
8833 }
8834
8835
8836 static PyObject *_wrap_NativeFontInfo_FromUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8837 PyObject *resultobj;
8838 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8839 wxString *arg2 = 0 ;
8840 bool result;
8841 bool temp2 = false ;
8842 PyObject * obj0 = 0 ;
8843 PyObject * obj1 = 0 ;
8844 char *kwnames[] = {
8845 (char *) "self",(char *) "s", NULL
8846 };
8847
8848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromUserString",kwnames,&obj0,&obj1)) goto fail;
8849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8850 if (SWIG_arg_fail(1)) SWIG_fail;
8851 {
8852 arg2 = wxString_in_helper(obj1);
8853 if (arg2 == NULL) SWIG_fail;
8854 temp2 = true;
8855 }
8856 {
8857 PyThreadState* __tstate = wxPyBeginAllowThreads();
8858 result = (bool)(arg1)->FromUserString((wxString const &)*arg2);
8859
8860 wxPyEndAllowThreads(__tstate);
8861 if (PyErr_Occurred()) SWIG_fail;
8862 }
8863 {
8864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8865 }
8866 {
8867 if (temp2)
8868 delete arg2;
8869 }
8870 return resultobj;
8871 fail:
8872 {
8873 if (temp2)
8874 delete arg2;
8875 }
8876 return NULL;
8877 }
8878
8879
8880 static PyObject *_wrap_NativeFontInfo_ToUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8881 PyObject *resultobj;
8882 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8883 wxString result;
8884 PyObject * obj0 = 0 ;
8885 char *kwnames[] = {
8886 (char *) "self", NULL
8887 };
8888
8889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToUserString",kwnames,&obj0)) goto fail;
8890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8891 if (SWIG_arg_fail(1)) SWIG_fail;
8892 {
8893 PyThreadState* __tstate = wxPyBeginAllowThreads();
8894 result = ((wxNativeFontInfo const *)arg1)->ToUserString();
8895
8896 wxPyEndAllowThreads(__tstate);
8897 if (PyErr_Occurred()) SWIG_fail;
8898 }
8899 {
8900 #if wxUSE_UNICODE
8901 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8902 #else
8903 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8904 #endif
8905 }
8906 return resultobj;
8907 fail:
8908 return NULL;
8909 }
8910
8911
8912 static PyObject * NativeFontInfo_swigregister(PyObject *, PyObject *args) {
8913 PyObject *obj;
8914 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8915 SWIG_TypeClientData(SWIGTYPE_p_wxNativeFontInfo, obj);
8916 Py_INCREF(obj);
8917 return Py_BuildValue((char *)"");
8918 }
8919 static PyObject *_wrap_NativeEncodingInfo_facename_set(PyObject *, PyObject *args, PyObject *kwargs) {
8920 PyObject *resultobj;
8921 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8922 wxString *arg2 = (wxString *) 0 ;
8923 bool temp2 = false ;
8924 PyObject * obj0 = 0 ;
8925 PyObject * obj1 = 0 ;
8926 char *kwnames[] = {
8927 (char *) "self",(char *) "facename", NULL
8928 };
8929
8930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_facename_set",kwnames,&obj0,&obj1)) goto fail;
8931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8932 if (SWIG_arg_fail(1)) SWIG_fail;
8933 {
8934 arg2 = wxString_in_helper(obj1);
8935 if (arg2 == NULL) SWIG_fail;
8936 temp2 = true;
8937 }
8938 if (arg1) (arg1)->facename = *arg2;
8939
8940 Py_INCREF(Py_None); resultobj = Py_None;
8941 {
8942 if (temp2)
8943 delete arg2;
8944 }
8945 return resultobj;
8946 fail:
8947 {
8948 if (temp2)
8949 delete arg2;
8950 }
8951 return NULL;
8952 }
8953
8954
8955 static PyObject *_wrap_NativeEncodingInfo_facename_get(PyObject *, PyObject *args, PyObject *kwargs) {
8956 PyObject *resultobj;
8957 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8958 wxString *result;
8959 PyObject * obj0 = 0 ;
8960 char *kwnames[] = {
8961 (char *) "self", NULL
8962 };
8963
8964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_facename_get",kwnames,&obj0)) goto fail;
8965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8966 if (SWIG_arg_fail(1)) SWIG_fail;
8967 result = (wxString *)& ((arg1)->facename);
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_NativeEncodingInfo_encoding_set(PyObject *, PyObject *args, PyObject *kwargs) {
8983 PyObject *resultobj;
8984 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8985 wxFontEncoding arg2 ;
8986 PyObject * obj0 = 0 ;
8987 PyObject * obj1 = 0 ;
8988 char *kwnames[] = {
8989 (char *) "self",(char *) "encoding", NULL
8990 };
8991
8992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_encoding_set",kwnames,&obj0,&obj1)) goto fail;
8993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8994 if (SWIG_arg_fail(1)) SWIG_fail;
8995 {
8996 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8997 if (SWIG_arg_fail(2)) SWIG_fail;
8998 }
8999 if (arg1) (arg1)->encoding = (wxFontEncoding )arg2;
9000
9001 Py_INCREF(Py_None); resultobj = Py_None;
9002 return resultobj;
9003 fail:
9004 return NULL;
9005 }
9006
9007
9008 static PyObject *_wrap_NativeEncodingInfo_encoding_get(PyObject *, PyObject *args, PyObject *kwargs) {
9009 PyObject *resultobj;
9010 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9011 wxFontEncoding result;
9012 PyObject * obj0 = 0 ;
9013 char *kwnames[] = {
9014 (char *) "self", NULL
9015 };
9016
9017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_encoding_get",kwnames,&obj0)) goto fail;
9018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9019 if (SWIG_arg_fail(1)) SWIG_fail;
9020 result = (wxFontEncoding) ((arg1)->encoding);
9021
9022 resultobj = SWIG_From_int((result));
9023 return resultobj;
9024 fail:
9025 return NULL;
9026 }
9027
9028
9029 static PyObject *_wrap_new_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9030 PyObject *resultobj;
9031 wxNativeEncodingInfo *result;
9032 char *kwnames[] = {
9033 NULL
9034 };
9035
9036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeEncodingInfo",kwnames)) goto fail;
9037 {
9038 PyThreadState* __tstate = wxPyBeginAllowThreads();
9039 result = (wxNativeEncodingInfo *)new wxNativeEncodingInfo();
9040
9041 wxPyEndAllowThreads(__tstate);
9042 if (PyErr_Occurred()) SWIG_fail;
9043 }
9044 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 1);
9045 return resultobj;
9046 fail:
9047 return NULL;
9048 }
9049
9050
9051 static PyObject *_wrap_delete_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9052 PyObject *resultobj;
9053 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9054 PyObject * obj0 = 0 ;
9055 char *kwnames[] = {
9056 (char *) "self", NULL
9057 };
9058
9059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeEncodingInfo",kwnames,&obj0)) goto fail;
9060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9061 if (SWIG_arg_fail(1)) SWIG_fail;
9062 {
9063 PyThreadState* __tstate = wxPyBeginAllowThreads();
9064 delete arg1;
9065
9066 wxPyEndAllowThreads(__tstate);
9067 if (PyErr_Occurred()) SWIG_fail;
9068 }
9069 Py_INCREF(Py_None); resultobj = Py_None;
9070 return resultobj;
9071 fail:
9072 return NULL;
9073 }
9074
9075
9076 static PyObject *_wrap_NativeEncodingInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
9077 PyObject *resultobj;
9078 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9079 wxString *arg2 = 0 ;
9080 bool result;
9081 bool temp2 = false ;
9082 PyObject * obj0 = 0 ;
9083 PyObject * obj1 = 0 ;
9084 char *kwnames[] = {
9085 (char *) "self",(char *) "s", NULL
9086 };
9087
9088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
9089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9090 if (SWIG_arg_fail(1)) SWIG_fail;
9091 {
9092 arg2 = wxString_in_helper(obj1);
9093 if (arg2 == NULL) SWIG_fail;
9094 temp2 = true;
9095 }
9096 {
9097 PyThreadState* __tstate = wxPyBeginAllowThreads();
9098 result = (bool)(arg1)->FromString((wxString const &)*arg2);
9099
9100 wxPyEndAllowThreads(__tstate);
9101 if (PyErr_Occurred()) SWIG_fail;
9102 }
9103 {
9104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9105 }
9106 {
9107 if (temp2)
9108 delete arg2;
9109 }
9110 return resultobj;
9111 fail:
9112 {
9113 if (temp2)
9114 delete arg2;
9115 }
9116 return NULL;
9117 }
9118
9119
9120 static PyObject *_wrap_NativeEncodingInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
9121 PyObject *resultobj;
9122 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9123 wxString result;
9124 PyObject * obj0 = 0 ;
9125 char *kwnames[] = {
9126 (char *) "self", NULL
9127 };
9128
9129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_ToString",kwnames,&obj0)) goto fail;
9130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9131 if (SWIG_arg_fail(1)) SWIG_fail;
9132 {
9133 PyThreadState* __tstate = wxPyBeginAllowThreads();
9134 result = ((wxNativeEncodingInfo const *)arg1)->ToString();
9135
9136 wxPyEndAllowThreads(__tstate);
9137 if (PyErr_Occurred()) SWIG_fail;
9138 }
9139 {
9140 #if wxUSE_UNICODE
9141 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9142 #else
9143 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9144 #endif
9145 }
9146 return resultobj;
9147 fail:
9148 return NULL;
9149 }
9150
9151
9152 static PyObject * NativeEncodingInfo_swigregister(PyObject *, PyObject *args) {
9153 PyObject *obj;
9154 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9155 SWIG_TypeClientData(SWIGTYPE_p_wxNativeEncodingInfo, obj);
9156 Py_INCREF(obj);
9157 return Py_BuildValue((char *)"");
9158 }
9159 static PyObject *_wrap_GetNativeFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9160 PyObject *resultobj;
9161 wxFontEncoding arg1 ;
9162 wxNativeEncodingInfo *result;
9163 PyObject * obj0 = 0 ;
9164 char *kwnames[] = {
9165 (char *) "encoding", NULL
9166 };
9167
9168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetNativeFontEncoding",kwnames,&obj0)) goto fail;
9169 {
9170 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
9171 if (SWIG_arg_fail(1)) SWIG_fail;
9172 }
9173 {
9174 PyThreadState* __tstate = wxPyBeginAllowThreads();
9175 result = (wxNativeEncodingInfo *)wxGetNativeFontEncoding((wxFontEncoding )arg1);
9176
9177 wxPyEndAllowThreads(__tstate);
9178 if (PyErr_Occurred()) SWIG_fail;
9179 }
9180 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 0);
9181 return resultobj;
9182 fail:
9183 return NULL;
9184 }
9185
9186
9187 static PyObject *_wrap_TestFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9188 PyObject *resultobj;
9189 wxNativeEncodingInfo *arg1 = 0 ;
9190 bool result;
9191 PyObject * obj0 = 0 ;
9192 char *kwnames[] = {
9193 (char *) "info", NULL
9194 };
9195
9196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TestFontEncoding",kwnames,&obj0)) goto fail;
9197 {
9198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9199 if (SWIG_arg_fail(1)) SWIG_fail;
9200 if (arg1 == NULL) {
9201 SWIG_null_ref("wxNativeEncodingInfo");
9202 }
9203 if (SWIG_arg_fail(1)) SWIG_fail;
9204 }
9205 {
9206 PyThreadState* __tstate = wxPyBeginAllowThreads();
9207 result = (bool)wxTestFontEncoding((wxNativeEncodingInfo const &)*arg1);
9208
9209 wxPyEndAllowThreads(__tstate);
9210 if (PyErr_Occurred()) SWIG_fail;
9211 }
9212 {
9213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9214 }
9215 return resultobj;
9216 fail:
9217 return NULL;
9218 }
9219
9220
9221 static PyObject *_wrap_new_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
9222 PyObject *resultobj;
9223 wxFontMapper *result;
9224 char *kwnames[] = {
9225 NULL
9226 };
9227
9228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontMapper",kwnames)) goto fail;
9229 {
9230 PyThreadState* __tstate = wxPyBeginAllowThreads();
9231 result = (wxFontMapper *)new wxFontMapper();
9232
9233 wxPyEndAllowThreads(__tstate);
9234 if (PyErr_Occurred()) SWIG_fail;
9235 }
9236 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 1);
9237 return resultobj;
9238 fail:
9239 return NULL;
9240 }
9241
9242
9243 static PyObject *_wrap_delete_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
9244 PyObject *resultobj;
9245 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9246 PyObject * obj0 = 0 ;
9247 char *kwnames[] = {
9248 (char *) "self", NULL
9249 };
9250
9251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontMapper",kwnames,&obj0)) goto fail;
9252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9253 if (SWIG_arg_fail(1)) SWIG_fail;
9254 {
9255 PyThreadState* __tstate = wxPyBeginAllowThreads();
9256 delete arg1;
9257
9258 wxPyEndAllowThreads(__tstate);
9259 if (PyErr_Occurred()) SWIG_fail;
9260 }
9261 Py_INCREF(Py_None); resultobj = Py_None;
9262 return resultobj;
9263 fail:
9264 return NULL;
9265 }
9266
9267
9268 static PyObject *_wrap_FontMapper_Get(PyObject *, PyObject *args, PyObject *kwargs) {
9269 PyObject *resultobj;
9270 wxFontMapper *result;
9271 char *kwnames[] = {
9272 NULL
9273 };
9274
9275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_Get",kwnames)) goto fail;
9276 {
9277 PyThreadState* __tstate = wxPyBeginAllowThreads();
9278 result = (wxFontMapper *)wxFontMapper::Get();
9279
9280 wxPyEndAllowThreads(__tstate);
9281 if (PyErr_Occurred()) SWIG_fail;
9282 }
9283 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
9284 return resultobj;
9285 fail:
9286 return NULL;
9287 }
9288
9289
9290 static PyObject *_wrap_FontMapper_Set(PyObject *, PyObject *args, PyObject *kwargs) {
9291 PyObject *resultobj;
9292 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9293 wxFontMapper *result;
9294 PyObject * obj0 = 0 ;
9295 char *kwnames[] = {
9296 (char *) "mapper", NULL
9297 };
9298
9299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_Set",kwnames,&obj0)) goto fail;
9300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9301 if (SWIG_arg_fail(1)) SWIG_fail;
9302 {
9303 PyThreadState* __tstate = wxPyBeginAllowThreads();
9304 result = (wxFontMapper *)wxFontMapper::Set(arg1);
9305
9306 wxPyEndAllowThreads(__tstate);
9307 if (PyErr_Occurred()) SWIG_fail;
9308 }
9309 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
9310 return resultobj;
9311 fail:
9312 return NULL;
9313 }
9314
9315
9316 static PyObject *_wrap_FontMapper_CharsetToEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9317 PyObject *resultobj;
9318 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9319 wxString *arg2 = 0 ;
9320 bool arg3 = (bool) true ;
9321 wxFontEncoding result;
9322 bool temp2 = false ;
9323 PyObject * obj0 = 0 ;
9324 PyObject * obj1 = 0 ;
9325 PyObject * obj2 = 0 ;
9326 char *kwnames[] = {
9327 (char *) "self",(char *) "charset",(char *) "interactive", NULL
9328 };
9329
9330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_CharsetToEncoding",kwnames,&obj0,&obj1,&obj2)) goto fail;
9331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9332 if (SWIG_arg_fail(1)) SWIG_fail;
9333 {
9334 arg2 = wxString_in_helper(obj1);
9335 if (arg2 == NULL) SWIG_fail;
9336 temp2 = true;
9337 }
9338 if (obj2) {
9339 {
9340 arg3 = (bool)(SWIG_As_bool(obj2));
9341 if (SWIG_arg_fail(3)) SWIG_fail;
9342 }
9343 }
9344 {
9345 PyThreadState* __tstate = wxPyBeginAllowThreads();
9346 result = (wxFontEncoding)(arg1)->CharsetToEncoding((wxString const &)*arg2,arg3);
9347
9348 wxPyEndAllowThreads(__tstate);
9349 if (PyErr_Occurred()) SWIG_fail;
9350 }
9351 resultobj = SWIG_From_int((result));
9352 {
9353 if (temp2)
9354 delete arg2;
9355 }
9356 return resultobj;
9357 fail:
9358 {
9359 if (temp2)
9360 delete arg2;
9361 }
9362 return NULL;
9363 }
9364
9365
9366 static PyObject *_wrap_FontMapper_GetSupportedEncodingsCount(PyObject *, PyObject *args, PyObject *kwargs) {
9367 PyObject *resultobj;
9368 size_t result;
9369 char *kwnames[] = {
9370 NULL
9371 };
9372
9373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetSupportedEncodingsCount",kwnames)) goto fail;
9374 {
9375 PyThreadState* __tstate = wxPyBeginAllowThreads();
9376 result = (size_t)wxFontMapper::GetSupportedEncodingsCount();
9377
9378 wxPyEndAllowThreads(__tstate);
9379 if (PyErr_Occurred()) SWIG_fail;
9380 }
9381 {
9382 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9383 }
9384 return resultobj;
9385 fail:
9386 return NULL;
9387 }
9388
9389
9390 static PyObject *_wrap_FontMapper_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9391 PyObject *resultobj;
9392 size_t arg1 ;
9393 wxFontEncoding result;
9394 PyObject * obj0 = 0 ;
9395 char *kwnames[] = {
9396 (char *) "n", NULL
9397 };
9398
9399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncoding",kwnames,&obj0)) goto fail;
9400 {
9401 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
9402 if (SWIG_arg_fail(1)) SWIG_fail;
9403 }
9404 {
9405 PyThreadState* __tstate = wxPyBeginAllowThreads();
9406 result = (wxFontEncoding)wxFontMapper::GetEncoding(arg1);
9407
9408 wxPyEndAllowThreads(__tstate);
9409 if (PyErr_Occurred()) SWIG_fail;
9410 }
9411 resultobj = SWIG_From_int((result));
9412 return resultobj;
9413 fail:
9414 return NULL;
9415 }
9416
9417
9418 static PyObject *_wrap_FontMapper_GetEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
9419 PyObject *resultobj;
9420 wxFontEncoding arg1 ;
9421 wxString result;
9422 PyObject * obj0 = 0 ;
9423 char *kwnames[] = {
9424 (char *) "encoding", NULL
9425 };
9426
9427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingName",kwnames,&obj0)) goto fail;
9428 {
9429 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
9430 if (SWIG_arg_fail(1)) SWIG_fail;
9431 }
9432 {
9433 PyThreadState* __tstate = wxPyBeginAllowThreads();
9434 result = wxFontMapper::GetEncodingName((wxFontEncoding )arg1);
9435
9436 wxPyEndAllowThreads(__tstate);
9437 if (PyErr_Occurred()) SWIG_fail;
9438 }
9439 {
9440 #if wxUSE_UNICODE
9441 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9442 #else
9443 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9444 #endif
9445 }
9446 return resultobj;
9447 fail:
9448 return NULL;
9449 }
9450
9451
9452 static PyObject *_wrap_FontMapper_GetEncodingDescription(PyObject *, PyObject *args, PyObject *kwargs) {
9453 PyObject *resultobj;
9454 wxFontEncoding arg1 ;
9455 wxString result;
9456 PyObject * obj0 = 0 ;
9457 char *kwnames[] = {
9458 (char *) "encoding", NULL
9459 };
9460
9461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingDescription",kwnames,&obj0)) goto fail;
9462 {
9463 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
9464 if (SWIG_arg_fail(1)) SWIG_fail;
9465 }
9466 {
9467 PyThreadState* __tstate = wxPyBeginAllowThreads();
9468 result = wxFontMapper::GetEncodingDescription((wxFontEncoding )arg1);
9469
9470 wxPyEndAllowThreads(__tstate);
9471 if (PyErr_Occurred()) SWIG_fail;
9472 }
9473 {
9474 #if wxUSE_UNICODE
9475 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9476 #else
9477 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9478 #endif
9479 }
9480 return resultobj;
9481 fail:
9482 return NULL;
9483 }
9484
9485
9486 static PyObject *_wrap_FontMapper_GetEncodingFromName(PyObject *, PyObject *args, PyObject *kwargs) {
9487 PyObject *resultobj;
9488 wxString *arg1 = 0 ;
9489 wxFontEncoding result;
9490 bool temp1 = false ;
9491 PyObject * obj0 = 0 ;
9492 char *kwnames[] = {
9493 (char *) "name", NULL
9494 };
9495
9496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingFromName",kwnames,&obj0)) goto fail;
9497 {
9498 arg1 = wxString_in_helper(obj0);
9499 if (arg1 == NULL) SWIG_fail;
9500 temp1 = true;
9501 }
9502 {
9503 PyThreadState* __tstate = wxPyBeginAllowThreads();
9504 result = (wxFontEncoding)wxFontMapper::GetEncodingFromName((wxString const &)*arg1);
9505
9506 wxPyEndAllowThreads(__tstate);
9507 if (PyErr_Occurred()) SWIG_fail;
9508 }
9509 resultobj = SWIG_From_int((result));
9510 {
9511 if (temp1)
9512 delete arg1;
9513 }
9514 return resultobj;
9515 fail:
9516 {
9517 if (temp1)
9518 delete arg1;
9519 }
9520 return NULL;
9521 }
9522
9523
9524 static PyObject *_wrap_FontMapper_SetConfig(PyObject *, PyObject *args, PyObject *kwargs) {
9525 PyObject *resultobj;
9526 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9527 wxConfigBase *arg2 = (wxConfigBase *) 0 ;
9528 PyObject * obj0 = 0 ;
9529 PyObject * obj1 = 0 ;
9530 char *kwnames[] = {
9531 (char *) "self",(char *) "config", NULL
9532 };
9533
9534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfig",kwnames,&obj0,&obj1)) goto fail;
9535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9536 if (SWIG_arg_fail(1)) SWIG_fail;
9537 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
9538 if (SWIG_arg_fail(2)) SWIG_fail;
9539 {
9540 PyThreadState* __tstate = wxPyBeginAllowThreads();
9541 (arg1)->SetConfig(arg2);
9542
9543 wxPyEndAllowThreads(__tstate);
9544 if (PyErr_Occurred()) SWIG_fail;
9545 }
9546 Py_INCREF(Py_None); resultobj = Py_None;
9547 return resultobj;
9548 fail:
9549 return NULL;
9550 }
9551
9552
9553 static PyObject *_wrap_FontMapper_SetConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
9554 PyObject *resultobj;
9555 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9556 wxString *arg2 = 0 ;
9557 bool temp2 = false ;
9558 PyObject * obj0 = 0 ;
9559 PyObject * obj1 = 0 ;
9560 char *kwnames[] = {
9561 (char *) "self",(char *) "prefix", NULL
9562 };
9563
9564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfigPath",kwnames,&obj0,&obj1)) goto fail;
9565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9566 if (SWIG_arg_fail(1)) SWIG_fail;
9567 {
9568 arg2 = wxString_in_helper(obj1);
9569 if (arg2 == NULL) SWIG_fail;
9570 temp2 = true;
9571 }
9572 {
9573 PyThreadState* __tstate = wxPyBeginAllowThreads();
9574 (arg1)->SetConfigPath((wxString const &)*arg2);
9575
9576 wxPyEndAllowThreads(__tstate);
9577 if (PyErr_Occurred()) SWIG_fail;
9578 }
9579 Py_INCREF(Py_None); resultobj = Py_None;
9580 {
9581 if (temp2)
9582 delete arg2;
9583 }
9584 return resultobj;
9585 fail:
9586 {
9587 if (temp2)
9588 delete arg2;
9589 }
9590 return NULL;
9591 }
9592
9593
9594 static PyObject *_wrap_FontMapper_GetDefaultConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
9595 PyObject *resultobj;
9596 wxString result;
9597 char *kwnames[] = {
9598 NULL
9599 };
9600
9601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetDefaultConfigPath",kwnames)) goto fail;
9602 {
9603 PyThreadState* __tstate = wxPyBeginAllowThreads();
9604 result = wxFontMapper::GetDefaultConfigPath();
9605
9606 wxPyEndAllowThreads(__tstate);
9607 if (PyErr_Occurred()) SWIG_fail;
9608 }
9609 {
9610 #if wxUSE_UNICODE
9611 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9612 #else
9613 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9614 #endif
9615 }
9616 return resultobj;
9617 fail:
9618 return NULL;
9619 }
9620
9621
9622 static PyObject *_wrap_FontMapper_GetAltForEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9623 PyObject *resultobj;
9624 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9625 wxFontEncoding arg2 ;
9626 wxString const &arg3_defvalue = wxPyEmptyString ;
9627 wxString *arg3 = (wxString *) &arg3_defvalue ;
9628 bool arg4 = (bool) true ;
9629 PyObject *result;
9630 bool temp3 = false ;
9631 PyObject * obj0 = 0 ;
9632 PyObject * obj1 = 0 ;
9633 PyObject * obj2 = 0 ;
9634 PyObject * obj3 = 0 ;
9635 char *kwnames[] = {
9636 (char *) "self",(char *) "encoding",(char *) "facename",(char *) "interactive", NULL
9637 };
9638
9639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:FontMapper_GetAltForEncoding",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9641 if (SWIG_arg_fail(1)) SWIG_fail;
9642 {
9643 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9644 if (SWIG_arg_fail(2)) SWIG_fail;
9645 }
9646 if (obj2) {
9647 {
9648 arg3 = wxString_in_helper(obj2);
9649 if (arg3 == NULL) SWIG_fail;
9650 temp3 = true;
9651 }
9652 }
9653 if (obj3) {
9654 {
9655 arg4 = (bool)(SWIG_As_bool(obj3));
9656 if (SWIG_arg_fail(4)) SWIG_fail;
9657 }
9658 }
9659 {
9660 PyThreadState* __tstate = wxPyBeginAllowThreads();
9661 result = (PyObject *)wxFontMapper_GetAltForEncoding(arg1,(wxFontEncoding )arg2,(wxString const &)*arg3,arg4);
9662
9663 wxPyEndAllowThreads(__tstate);
9664 if (PyErr_Occurred()) SWIG_fail;
9665 }
9666 resultobj = result;
9667 {
9668 if (temp3)
9669 delete arg3;
9670 }
9671 return resultobj;
9672 fail:
9673 {
9674 if (temp3)
9675 delete arg3;
9676 }
9677 return NULL;
9678 }
9679
9680
9681 static PyObject *_wrap_FontMapper_IsEncodingAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
9682 PyObject *resultobj;
9683 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9684 wxFontEncoding arg2 ;
9685 wxString const &arg3_defvalue = wxPyEmptyString ;
9686 wxString *arg3 = (wxString *) &arg3_defvalue ;
9687 bool result;
9688 bool temp3 = false ;
9689 PyObject * obj0 = 0 ;
9690 PyObject * obj1 = 0 ;
9691 PyObject * obj2 = 0 ;
9692 char *kwnames[] = {
9693 (char *) "self",(char *) "encoding",(char *) "facename", NULL
9694 };
9695
9696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_IsEncodingAvailable",kwnames,&obj0,&obj1,&obj2)) goto fail;
9697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9698 if (SWIG_arg_fail(1)) SWIG_fail;
9699 {
9700 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9701 if (SWIG_arg_fail(2)) SWIG_fail;
9702 }
9703 if (obj2) {
9704 {
9705 arg3 = wxString_in_helper(obj2);
9706 if (arg3 == NULL) SWIG_fail;
9707 temp3 = true;
9708 }
9709 }
9710 {
9711 PyThreadState* __tstate = wxPyBeginAllowThreads();
9712 result = (bool)(arg1)->IsEncodingAvailable((wxFontEncoding )arg2,(wxString const &)*arg3);
9713
9714 wxPyEndAllowThreads(__tstate);
9715 if (PyErr_Occurred()) SWIG_fail;
9716 }
9717 {
9718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9719 }
9720 {
9721 if (temp3)
9722 delete arg3;
9723 }
9724 return resultobj;
9725 fail:
9726 {
9727 if (temp3)
9728 delete arg3;
9729 }
9730 return NULL;
9731 }
9732
9733
9734 static PyObject *_wrap_FontMapper_SetDialogParent(PyObject *, PyObject *args, PyObject *kwargs) {
9735 PyObject *resultobj;
9736 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9737 wxWindow *arg2 = (wxWindow *) 0 ;
9738 PyObject * obj0 = 0 ;
9739 PyObject * obj1 = 0 ;
9740 char *kwnames[] = {
9741 (char *) "self",(char *) "parent", NULL
9742 };
9743
9744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogParent",kwnames,&obj0,&obj1)) goto fail;
9745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9746 if (SWIG_arg_fail(1)) SWIG_fail;
9747 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9748 if (SWIG_arg_fail(2)) SWIG_fail;
9749 {
9750 PyThreadState* __tstate = wxPyBeginAllowThreads();
9751 (arg1)->SetDialogParent(arg2);
9752
9753 wxPyEndAllowThreads(__tstate);
9754 if (PyErr_Occurred()) SWIG_fail;
9755 }
9756 Py_INCREF(Py_None); resultobj = Py_None;
9757 return resultobj;
9758 fail:
9759 return NULL;
9760 }
9761
9762
9763 static PyObject *_wrap_FontMapper_SetDialogTitle(PyObject *, PyObject *args, PyObject *kwargs) {
9764 PyObject *resultobj;
9765 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9766 wxString *arg2 = 0 ;
9767 bool temp2 = false ;
9768 PyObject * obj0 = 0 ;
9769 PyObject * obj1 = 0 ;
9770 char *kwnames[] = {
9771 (char *) "self",(char *) "title", NULL
9772 };
9773
9774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogTitle",kwnames,&obj0,&obj1)) goto fail;
9775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9776 if (SWIG_arg_fail(1)) SWIG_fail;
9777 {
9778 arg2 = wxString_in_helper(obj1);
9779 if (arg2 == NULL) SWIG_fail;
9780 temp2 = true;
9781 }
9782 {
9783 PyThreadState* __tstate = wxPyBeginAllowThreads();
9784 (arg1)->SetDialogTitle((wxString const &)*arg2);
9785
9786 wxPyEndAllowThreads(__tstate);
9787 if (PyErr_Occurred()) SWIG_fail;
9788 }
9789 Py_INCREF(Py_None); resultobj = Py_None;
9790 {
9791 if (temp2)
9792 delete arg2;
9793 }
9794 return resultobj;
9795 fail:
9796 {
9797 if (temp2)
9798 delete arg2;
9799 }
9800 return NULL;
9801 }
9802
9803
9804 static PyObject * FontMapper_swigregister(PyObject *, PyObject *args) {
9805 PyObject *obj;
9806 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9807 SWIG_TypeClientData(SWIGTYPE_p_wxFontMapper, obj);
9808 Py_INCREF(obj);
9809 return Py_BuildValue((char *)"");
9810 }
9811 static PyObject *_wrap_new_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9812 PyObject *resultobj;
9813 int arg1 ;
9814 int arg2 ;
9815 int arg3 ;
9816 int arg4 ;
9817 bool arg5 = (bool) false ;
9818 wxString const &arg6_defvalue = wxPyEmptyString ;
9819 wxString *arg6 = (wxString *) &arg6_defvalue ;
9820 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9821 wxFont *result;
9822 bool temp6 = false ;
9823 PyObject * obj0 = 0 ;
9824 PyObject * obj1 = 0 ;
9825 PyObject * obj2 = 0 ;
9826 PyObject * obj3 = 0 ;
9827 PyObject * obj4 = 0 ;
9828 PyObject * obj5 = 0 ;
9829 PyObject * obj6 = 0 ;
9830 char *kwnames[] = {
9831 (char *) "pointSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "face",(char *) "encoding", NULL
9832 };
9833
9834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_Font",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9835 {
9836 arg1 = (int)(SWIG_As_int(obj0));
9837 if (SWIG_arg_fail(1)) SWIG_fail;
9838 }
9839 {
9840 arg2 = (int)(SWIG_As_int(obj1));
9841 if (SWIG_arg_fail(2)) SWIG_fail;
9842 }
9843 {
9844 arg3 = (int)(SWIG_As_int(obj2));
9845 if (SWIG_arg_fail(3)) SWIG_fail;
9846 }
9847 {
9848 arg4 = (int)(SWIG_As_int(obj3));
9849 if (SWIG_arg_fail(4)) SWIG_fail;
9850 }
9851 if (obj4) {
9852 {
9853 arg5 = (bool)(SWIG_As_bool(obj4));
9854 if (SWIG_arg_fail(5)) SWIG_fail;
9855 }
9856 }
9857 if (obj5) {
9858 {
9859 arg6 = wxString_in_helper(obj5);
9860 if (arg6 == NULL) SWIG_fail;
9861 temp6 = true;
9862 }
9863 }
9864 if (obj6) {
9865 {
9866 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9867 if (SWIG_arg_fail(7)) SWIG_fail;
9868 }
9869 }
9870 {
9871 if (!wxPyCheckForApp()) SWIG_fail;
9872 PyThreadState* __tstate = wxPyBeginAllowThreads();
9873 result = (wxFont *)new wxFont(arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9874
9875 wxPyEndAllowThreads(__tstate);
9876 if (PyErr_Occurred()) SWIG_fail;
9877 }
9878 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9879 {
9880 if (temp6)
9881 delete arg6;
9882 }
9883 return resultobj;
9884 fail:
9885 {
9886 if (temp6)
9887 delete arg6;
9888 }
9889 return NULL;
9890 }
9891
9892
9893 static PyObject *_wrap_delete_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9894 PyObject *resultobj;
9895 wxFont *arg1 = (wxFont *) 0 ;
9896 PyObject * obj0 = 0 ;
9897 char *kwnames[] = {
9898 (char *) "self", NULL
9899 };
9900
9901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Font",kwnames,&obj0)) goto fail;
9902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9903 if (SWIG_arg_fail(1)) SWIG_fail;
9904 {
9905 PyThreadState* __tstate = wxPyBeginAllowThreads();
9906 delete arg1;
9907
9908 wxPyEndAllowThreads(__tstate);
9909 if (PyErr_Occurred()) SWIG_fail;
9910 }
9911 Py_INCREF(Py_None); resultobj = Py_None;
9912 return resultobj;
9913 fail:
9914 return NULL;
9915 }
9916
9917
9918 static PyObject *_wrap_new_FontFromNativeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9919 PyObject *resultobj;
9920 wxNativeFontInfo *arg1 = 0 ;
9921 wxFont *result;
9922 PyObject * obj0 = 0 ;
9923 char *kwnames[] = {
9924 (char *) "info", NULL
9925 };
9926
9927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfo",kwnames,&obj0)) goto fail;
9928 {
9929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
9930 if (SWIG_arg_fail(1)) SWIG_fail;
9931 if (arg1 == NULL) {
9932 SWIG_null_ref("wxNativeFontInfo");
9933 }
9934 if (SWIG_arg_fail(1)) SWIG_fail;
9935 }
9936 {
9937 if (!wxPyCheckForApp()) SWIG_fail;
9938 PyThreadState* __tstate = wxPyBeginAllowThreads();
9939 result = (wxFont *)new wxFont((wxNativeFontInfo const &)*arg1);
9940
9941 wxPyEndAllowThreads(__tstate);
9942 if (PyErr_Occurred()) SWIG_fail;
9943 }
9944 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9945 return resultobj;
9946 fail:
9947 return NULL;
9948 }
9949
9950
9951 static PyObject *_wrap_new_FontFromNativeInfoString(PyObject *, PyObject *args, PyObject *kwargs) {
9952 PyObject *resultobj;
9953 wxString *arg1 = 0 ;
9954 wxFont *result;
9955 bool temp1 = false ;
9956 PyObject * obj0 = 0 ;
9957 char *kwnames[] = {
9958 (char *) "info", NULL
9959 };
9960
9961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfoString",kwnames,&obj0)) goto fail;
9962 {
9963 arg1 = wxString_in_helper(obj0);
9964 if (arg1 == NULL) SWIG_fail;
9965 temp1 = true;
9966 }
9967 {
9968 if (!wxPyCheckForApp()) SWIG_fail;
9969 PyThreadState* __tstate = wxPyBeginAllowThreads();
9970 result = (wxFont *)new_wxFont((wxString const &)*arg1);
9971
9972 wxPyEndAllowThreads(__tstate);
9973 if (PyErr_Occurred()) SWIG_fail;
9974 }
9975 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9976 {
9977 if (temp1)
9978 delete arg1;
9979 }
9980 return resultobj;
9981 fail:
9982 {
9983 if (temp1)
9984 delete arg1;
9985 }
9986 return NULL;
9987 }
9988
9989
9990 static PyObject *_wrap_new_FFont(PyObject *, PyObject *args, PyObject *kwargs) {
9991 PyObject *resultobj;
9992 int arg1 ;
9993 wxFontFamily arg2 ;
9994 int arg3 = (int) wxFONTFLAG_DEFAULT ;
9995 wxString const &arg4_defvalue = wxPyEmptyString ;
9996 wxString *arg4 = (wxString *) &arg4_defvalue ;
9997 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9998 wxFont *result;
9999 bool temp4 = false ;
10000 PyObject * obj0 = 0 ;
10001 PyObject * obj1 = 0 ;
10002 PyObject * obj2 = 0 ;
10003 PyObject * obj3 = 0 ;
10004 PyObject * obj4 = 0 ;
10005 char *kwnames[] = {
10006 (char *) "pointSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
10007 };
10008
10009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_FFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
10010 {
10011 arg1 = (int)(SWIG_As_int(obj0));
10012 if (SWIG_arg_fail(1)) SWIG_fail;
10013 }
10014 {
10015 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
10016 if (SWIG_arg_fail(2)) SWIG_fail;
10017 }
10018 if (obj2) {
10019 {
10020 arg3 = (int)(SWIG_As_int(obj2));
10021 if (SWIG_arg_fail(3)) SWIG_fail;
10022 }
10023 }
10024 if (obj3) {
10025 {
10026 arg4 = wxString_in_helper(obj3);
10027 if (arg4 == NULL) SWIG_fail;
10028 temp4 = true;
10029 }
10030 }
10031 if (obj4) {
10032 {
10033 arg5 = (wxFontEncoding)(SWIG_As_int(obj4));
10034 if (SWIG_arg_fail(5)) SWIG_fail;
10035 }
10036 }
10037 {
10038 if (!wxPyCheckForApp()) SWIG_fail;
10039 PyThreadState* __tstate = wxPyBeginAllowThreads();
10040 result = (wxFont *)new_wxFont(arg1,(wxFontFamily )arg2,arg3,(wxString const &)*arg4,(wxFontEncoding )arg5);
10041
10042 wxPyEndAllowThreads(__tstate);
10043 if (PyErr_Occurred()) SWIG_fail;
10044 }
10045 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
10046 {
10047 if (temp4)
10048 delete arg4;
10049 }
10050 return resultobj;
10051 fail:
10052 {
10053 if (temp4)
10054 delete arg4;
10055 }
10056 return NULL;
10057 }
10058
10059
10060 static PyObject *_wrap_new_FontFromPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10061 PyObject *resultobj;
10062 wxSize *arg1 = 0 ;
10063 int arg2 ;
10064 int arg3 ;
10065 int arg4 ;
10066 bool arg5 = (bool) false ;
10067 wxString const &arg6_defvalue = wxEmptyString ;
10068 wxString *arg6 = (wxString *) &arg6_defvalue ;
10069 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
10070 wxFont *result;
10071 wxSize temp1 ;
10072 bool temp6 = false ;
10073 PyObject * obj0 = 0 ;
10074 PyObject * obj1 = 0 ;
10075 PyObject * obj2 = 0 ;
10076 PyObject * obj3 = 0 ;
10077 PyObject * obj4 = 0 ;
10078 PyObject * obj5 = 0 ;
10079 PyObject * obj6 = 0 ;
10080 char *kwnames[] = {
10081 (char *) "pixelSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underlined",(char *) "face",(char *) "encoding", NULL
10082 };
10083
10084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_FontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
10085 {
10086 arg1 = &temp1;
10087 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
10088 }
10089 {
10090 arg2 = (int)(SWIG_As_int(obj1));
10091 if (SWIG_arg_fail(2)) SWIG_fail;
10092 }
10093 {
10094 arg3 = (int)(SWIG_As_int(obj2));
10095 if (SWIG_arg_fail(3)) SWIG_fail;
10096 }
10097 {
10098 arg4 = (int)(SWIG_As_int(obj3));
10099 if (SWIG_arg_fail(4)) SWIG_fail;
10100 }
10101 if (obj4) {
10102 {
10103 arg5 = (bool)(SWIG_As_bool(obj4));
10104 if (SWIG_arg_fail(5)) SWIG_fail;
10105 }
10106 }
10107 if (obj5) {
10108 {
10109 arg6 = wxString_in_helper(obj5);
10110 if (arg6 == NULL) SWIG_fail;
10111 temp6 = true;
10112 }
10113 }
10114 if (obj6) {
10115 {
10116 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
10117 if (SWIG_arg_fail(7)) SWIG_fail;
10118 }
10119 }
10120 {
10121 if (!wxPyCheckForApp()) SWIG_fail;
10122 PyThreadState* __tstate = wxPyBeginAllowThreads();
10123 result = (wxFont *)new_wxFont((wxSize const &)*arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
10124
10125 wxPyEndAllowThreads(__tstate);
10126 if (PyErr_Occurred()) SWIG_fail;
10127 }
10128 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
10129 {
10130 if (temp6)
10131 delete arg6;
10132 }
10133 return resultobj;
10134 fail:
10135 {
10136 if (temp6)
10137 delete arg6;
10138 }
10139 return NULL;
10140 }
10141
10142
10143 static PyObject *_wrap_new_FFontFromPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10144 PyObject *resultobj;
10145 wxSize *arg1 = 0 ;
10146 wxFontFamily arg2 ;
10147 int arg3 = (int) wxFONTFLAG_DEFAULT ;
10148 wxString const &arg4_defvalue = wxEmptyString ;
10149 wxString *arg4 = (wxString *) &arg4_defvalue ;
10150 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
10151 wxFont *result;
10152 wxSize temp1 ;
10153 bool temp4 = false ;
10154 PyObject * obj0 = 0 ;
10155 PyObject * obj1 = 0 ;
10156 PyObject * obj2 = 0 ;
10157 PyObject * obj3 = 0 ;
10158 PyObject * obj4 = 0 ;
10159 char *kwnames[] = {
10160 (char *) "pixelSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
10161 };
10162
10163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_FFontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
10164 {
10165 arg1 = &temp1;
10166 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
10167 }
10168 {
10169 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
10170 if (SWIG_arg_fail(2)) SWIG_fail;
10171 }
10172 if (obj2) {
10173 {
10174 arg3 = (int)(SWIG_As_int(obj2));
10175 if (SWIG_arg_fail(3)) SWIG_fail;
10176 }
10177 }
10178 if (obj3) {
10179 {
10180 arg4 = wxString_in_helper(obj3);
10181 if (arg4 == NULL) SWIG_fail;
10182 temp4 = true;
10183 }
10184 }
10185 if (obj4) {
10186 {
10187 arg5 = (wxFontEncoding)(SWIG_As_int(obj4));
10188 if (SWIG_arg_fail(5)) SWIG_fail;
10189 }
10190 }
10191 {
10192 if (!wxPyCheckForApp()) SWIG_fail;
10193 PyThreadState* __tstate = wxPyBeginAllowThreads();
10194 result = (wxFont *)new_wxFont((wxSize const &)*arg1,(wxFontFamily )arg2,arg3,(wxString const &)*arg4,(wxFontEncoding )arg5);
10195
10196 wxPyEndAllowThreads(__tstate);
10197 if (PyErr_Occurred()) SWIG_fail;
10198 }
10199 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
10200 {
10201 if (temp4)
10202 delete arg4;
10203 }
10204 return resultobj;
10205 fail:
10206 {
10207 if (temp4)
10208 delete arg4;
10209 }
10210 return NULL;
10211 }
10212
10213
10214 static PyObject *_wrap_Font_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
10215 PyObject *resultobj;
10216 wxFont *arg1 = (wxFont *) 0 ;
10217 bool result;
10218 PyObject * obj0 = 0 ;
10219 char *kwnames[] = {
10220 (char *) "self", NULL
10221 };
10222
10223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_Ok",kwnames,&obj0)) goto fail;
10224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10225 if (SWIG_arg_fail(1)) SWIG_fail;
10226 {
10227 PyThreadState* __tstate = wxPyBeginAllowThreads();
10228 result = (bool)((wxFont const *)arg1)->Ok();
10229
10230 wxPyEndAllowThreads(__tstate);
10231 if (PyErr_Occurred()) SWIG_fail;
10232 }
10233 {
10234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10235 }
10236 return resultobj;
10237 fail:
10238 return NULL;
10239 }
10240
10241
10242 static PyObject *_wrap_Font___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
10243 PyObject *resultobj;
10244 wxFont *arg1 = (wxFont *) 0 ;
10245 wxFont *arg2 = (wxFont *) 0 ;
10246 bool result;
10247 PyObject * obj0 = 0 ;
10248 PyObject * obj1 = 0 ;
10249 char *kwnames[] = {
10250 (char *) "self",(char *) "other", NULL
10251 };
10252
10253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___eq__",kwnames,&obj0,&obj1)) goto fail;
10254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10255 if (SWIG_arg_fail(1)) SWIG_fail;
10256 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10257 if (SWIG_arg_fail(2)) SWIG_fail;
10258 {
10259 PyThreadState* __tstate = wxPyBeginAllowThreads();
10260 result = (bool)wxFont___eq__(arg1,(wxFont const *)arg2);
10261
10262 wxPyEndAllowThreads(__tstate);
10263 if (PyErr_Occurred()) SWIG_fail;
10264 }
10265 {
10266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10267 }
10268 return resultobj;
10269 fail:
10270 return NULL;
10271 }
10272
10273
10274 static PyObject *_wrap_Font___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
10275 PyObject *resultobj;
10276 wxFont *arg1 = (wxFont *) 0 ;
10277 wxFont *arg2 = (wxFont *) 0 ;
10278 bool result;
10279 PyObject * obj0 = 0 ;
10280 PyObject * obj1 = 0 ;
10281 char *kwnames[] = {
10282 (char *) "self",(char *) "other", NULL
10283 };
10284
10285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___ne__",kwnames,&obj0,&obj1)) goto fail;
10286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10287 if (SWIG_arg_fail(1)) SWIG_fail;
10288 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10289 if (SWIG_arg_fail(2)) SWIG_fail;
10290 {
10291 PyThreadState* __tstate = wxPyBeginAllowThreads();
10292 result = (bool)wxFont___ne__(arg1,(wxFont const *)arg2);
10293
10294 wxPyEndAllowThreads(__tstate);
10295 if (PyErr_Occurred()) SWIG_fail;
10296 }
10297 {
10298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10299 }
10300 return resultobj;
10301 fail:
10302 return NULL;
10303 }
10304
10305
10306 static PyObject *_wrap_Font_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
10307 PyObject *resultobj;
10308 wxFont *arg1 = (wxFont *) 0 ;
10309 int result;
10310 PyObject * obj0 = 0 ;
10311 char *kwnames[] = {
10312 (char *) "self", NULL
10313 };
10314
10315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPointSize",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
10320 result = (int)((wxFont const *)arg1)->GetPointSize();
10321
10322 wxPyEndAllowThreads(__tstate);
10323 if (PyErr_Occurred()) SWIG_fail;
10324 }
10325 {
10326 resultobj = SWIG_From_int((int)(result));
10327 }
10328 return resultobj;
10329 fail:
10330 return NULL;
10331 }
10332
10333
10334 static PyObject *_wrap_Font_GetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10335 PyObject *resultobj;
10336 wxFont *arg1 = (wxFont *) 0 ;
10337 wxSize result;
10338 PyObject * obj0 = 0 ;
10339 char *kwnames[] = {
10340 (char *) "self", NULL
10341 };
10342
10343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPixelSize",kwnames,&obj0)) goto fail;
10344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10345 if (SWIG_arg_fail(1)) SWIG_fail;
10346 {
10347 PyThreadState* __tstate = wxPyBeginAllowThreads();
10348 result = ((wxFont const *)arg1)->GetPixelSize();
10349
10350 wxPyEndAllowThreads(__tstate);
10351 if (PyErr_Occurred()) SWIG_fail;
10352 }
10353 {
10354 wxSize * resultptr;
10355 resultptr = new wxSize((wxSize &)(result));
10356 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
10357 }
10358 return resultobj;
10359 fail:
10360 return NULL;
10361 }
10362
10363
10364 static PyObject *_wrap_Font_IsUsingSizeInPixels(PyObject *, PyObject *args, PyObject *kwargs) {
10365 PyObject *resultobj;
10366 wxFont *arg1 = (wxFont *) 0 ;
10367 bool result;
10368 PyObject * obj0 = 0 ;
10369 char *kwnames[] = {
10370 (char *) "self", NULL
10371 };
10372
10373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsUsingSizeInPixels",kwnames,&obj0)) goto fail;
10374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10375 if (SWIG_arg_fail(1)) SWIG_fail;
10376 {
10377 PyThreadState* __tstate = wxPyBeginAllowThreads();
10378 result = (bool)((wxFont const *)arg1)->IsUsingSizeInPixels();
10379
10380 wxPyEndAllowThreads(__tstate);
10381 if (PyErr_Occurred()) SWIG_fail;
10382 }
10383 {
10384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10385 }
10386 return resultobj;
10387 fail:
10388 return NULL;
10389 }
10390
10391
10392 static PyObject *_wrap_Font_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
10393 PyObject *resultobj;
10394 wxFont *arg1 = (wxFont *) 0 ;
10395 int result;
10396 PyObject * obj0 = 0 ;
10397 char *kwnames[] = {
10398 (char *) "self", NULL
10399 };
10400
10401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamily",kwnames,&obj0)) goto fail;
10402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10403 if (SWIG_arg_fail(1)) SWIG_fail;
10404 {
10405 PyThreadState* __tstate = wxPyBeginAllowThreads();
10406 result = (int)((wxFont const *)arg1)->GetFamily();
10407
10408 wxPyEndAllowThreads(__tstate);
10409 if (PyErr_Occurred()) SWIG_fail;
10410 }
10411 {
10412 resultobj = SWIG_From_int((int)(result));
10413 }
10414 return resultobj;
10415 fail:
10416 return NULL;
10417 }
10418
10419
10420 static PyObject *_wrap_Font_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10421 PyObject *resultobj;
10422 wxFont *arg1 = (wxFont *) 0 ;
10423 int result;
10424 PyObject * obj0 = 0 ;
10425 char *kwnames[] = {
10426 (char *) "self", NULL
10427 };
10428
10429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyle",kwnames,&obj0)) goto fail;
10430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10431 if (SWIG_arg_fail(1)) SWIG_fail;
10432 {
10433 PyThreadState* __tstate = wxPyBeginAllowThreads();
10434 result = (int)((wxFont const *)arg1)->GetStyle();
10435
10436 wxPyEndAllowThreads(__tstate);
10437 if (PyErr_Occurred()) SWIG_fail;
10438 }
10439 {
10440 resultobj = SWIG_From_int((int)(result));
10441 }
10442 return resultobj;
10443 fail:
10444 return NULL;
10445 }
10446
10447
10448 static PyObject *_wrap_Font_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
10449 PyObject *resultobj;
10450 wxFont *arg1 = (wxFont *) 0 ;
10451 int result;
10452 PyObject * obj0 = 0 ;
10453 char *kwnames[] = {
10454 (char *) "self", NULL
10455 };
10456
10457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeight",kwnames,&obj0)) goto fail;
10458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10459 if (SWIG_arg_fail(1)) SWIG_fail;
10460 {
10461 PyThreadState* __tstate = wxPyBeginAllowThreads();
10462 result = (int)((wxFont const *)arg1)->GetWeight();
10463
10464 wxPyEndAllowThreads(__tstate);
10465 if (PyErr_Occurred()) SWIG_fail;
10466 }
10467 {
10468 resultobj = SWIG_From_int((int)(result));
10469 }
10470 return resultobj;
10471 fail:
10472 return NULL;
10473 }
10474
10475
10476 static PyObject *_wrap_Font_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
10477 PyObject *resultobj;
10478 wxFont *arg1 = (wxFont *) 0 ;
10479 bool result;
10480 PyObject * obj0 = 0 ;
10481 char *kwnames[] = {
10482 (char *) "self", NULL
10483 };
10484
10485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetUnderlined",kwnames,&obj0)) goto fail;
10486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10487 if (SWIG_arg_fail(1)) SWIG_fail;
10488 {
10489 PyThreadState* __tstate = wxPyBeginAllowThreads();
10490 result = (bool)((wxFont const *)arg1)->GetUnderlined();
10491
10492 wxPyEndAllowThreads(__tstate);
10493 if (PyErr_Occurred()) SWIG_fail;
10494 }
10495 {
10496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10497 }
10498 return resultobj;
10499 fail:
10500 return NULL;
10501 }
10502
10503
10504 static PyObject *_wrap_Font_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
10505 PyObject *resultobj;
10506 wxFont *arg1 = (wxFont *) 0 ;
10507 wxString result;
10508 PyObject * obj0 = 0 ;
10509 char *kwnames[] = {
10510 (char *) "self", NULL
10511 };
10512
10513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFaceName",kwnames,&obj0)) goto fail;
10514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10515 if (SWIG_arg_fail(1)) SWIG_fail;
10516 {
10517 PyThreadState* __tstate = wxPyBeginAllowThreads();
10518 result = ((wxFont const *)arg1)->GetFaceName();
10519
10520 wxPyEndAllowThreads(__tstate);
10521 if (PyErr_Occurred()) SWIG_fail;
10522 }
10523 {
10524 #if wxUSE_UNICODE
10525 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10526 #else
10527 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10528 #endif
10529 }
10530 return resultobj;
10531 fail:
10532 return NULL;
10533 }
10534
10535
10536 static PyObject *_wrap_Font_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10537 PyObject *resultobj;
10538 wxFont *arg1 = (wxFont *) 0 ;
10539 wxFontEncoding result;
10540 PyObject * obj0 = 0 ;
10541 char *kwnames[] = {
10542 (char *) "self", NULL
10543 };
10544
10545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetEncoding",kwnames,&obj0)) goto fail;
10546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10547 if (SWIG_arg_fail(1)) SWIG_fail;
10548 {
10549 PyThreadState* __tstate = wxPyBeginAllowThreads();
10550 result = (wxFontEncoding)((wxFont const *)arg1)->GetEncoding();
10551
10552 wxPyEndAllowThreads(__tstate);
10553 if (PyErr_Occurred()) SWIG_fail;
10554 }
10555 resultobj = SWIG_From_int((result));
10556 return resultobj;
10557 fail:
10558 return NULL;
10559 }
10560
10561
10562 static PyObject *_wrap_Font_GetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10563 PyObject *resultobj;
10564 wxFont *arg1 = (wxFont *) 0 ;
10565 wxNativeFontInfo *result;
10566 PyObject * obj0 = 0 ;
10567 char *kwnames[] = {
10568 (char *) "self", NULL
10569 };
10570
10571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfo",kwnames,&obj0)) goto fail;
10572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10573 if (SWIG_arg_fail(1)) SWIG_fail;
10574 {
10575 PyThreadState* __tstate = wxPyBeginAllowThreads();
10576 result = (wxNativeFontInfo *)((wxFont const *)arg1)->GetNativeFontInfo();
10577
10578 wxPyEndAllowThreads(__tstate);
10579 if (PyErr_Occurred()) SWIG_fail;
10580 }
10581 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 0);
10582 return resultobj;
10583 fail:
10584 return NULL;
10585 }
10586
10587
10588 static PyObject *_wrap_Font_IsFixedWidth(PyObject *, PyObject *args, PyObject *kwargs) {
10589 PyObject *resultobj;
10590 wxFont *arg1 = (wxFont *) 0 ;
10591 bool result;
10592 PyObject * obj0 = 0 ;
10593 char *kwnames[] = {
10594 (char *) "self", NULL
10595 };
10596
10597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsFixedWidth",kwnames,&obj0)) goto fail;
10598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10599 if (SWIG_arg_fail(1)) SWIG_fail;
10600 {
10601 PyThreadState* __tstate = wxPyBeginAllowThreads();
10602 result = (bool)((wxFont const *)arg1)->IsFixedWidth();
10603
10604 wxPyEndAllowThreads(__tstate);
10605 if (PyErr_Occurred()) SWIG_fail;
10606 }
10607 {
10608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10609 }
10610 return resultobj;
10611 fail:
10612 return NULL;
10613 }
10614
10615
10616 static PyObject *_wrap_Font_GetNativeFontInfoDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10617 PyObject *resultobj;
10618 wxFont *arg1 = (wxFont *) 0 ;
10619 wxString result;
10620 PyObject * obj0 = 0 ;
10621 char *kwnames[] = {
10622 (char *) "self", NULL
10623 };
10624
10625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoDesc",kwnames,&obj0)) goto fail;
10626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10627 if (SWIG_arg_fail(1)) SWIG_fail;
10628 {
10629 PyThreadState* __tstate = wxPyBeginAllowThreads();
10630 result = ((wxFont const *)arg1)->GetNativeFontInfoDesc();
10631
10632 wxPyEndAllowThreads(__tstate);
10633 if (PyErr_Occurred()) SWIG_fail;
10634 }
10635 {
10636 #if wxUSE_UNICODE
10637 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10638 #else
10639 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10640 #endif
10641 }
10642 return resultobj;
10643 fail:
10644 return NULL;
10645 }
10646
10647
10648 static PyObject *_wrap_Font_GetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10649 PyObject *resultobj;
10650 wxFont *arg1 = (wxFont *) 0 ;
10651 wxString result;
10652 PyObject * obj0 = 0 ;
10653 char *kwnames[] = {
10654 (char *) "self", NULL
10655 };
10656
10657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoUserDesc",kwnames,&obj0)) goto fail;
10658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10659 if (SWIG_arg_fail(1)) SWIG_fail;
10660 {
10661 PyThreadState* __tstate = wxPyBeginAllowThreads();
10662 result = ((wxFont const *)arg1)->GetNativeFontInfoUserDesc();
10663
10664 wxPyEndAllowThreads(__tstate);
10665 if (PyErr_Occurred()) SWIG_fail;
10666 }
10667 {
10668 #if wxUSE_UNICODE
10669 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10670 #else
10671 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10672 #endif
10673 }
10674 return resultobj;
10675 fail:
10676 return NULL;
10677 }
10678
10679
10680 static PyObject *_wrap_Font_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
10681 PyObject *resultobj;
10682 wxFont *arg1 = (wxFont *) 0 ;
10683 int arg2 ;
10684 PyObject * obj0 = 0 ;
10685 PyObject * obj1 = 0 ;
10686 char *kwnames[] = {
10687 (char *) "self",(char *) "pointSize", NULL
10688 };
10689
10690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
10691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10692 if (SWIG_arg_fail(1)) SWIG_fail;
10693 {
10694 arg2 = (int)(SWIG_As_int(obj1));
10695 if (SWIG_arg_fail(2)) SWIG_fail;
10696 }
10697 {
10698 PyThreadState* __tstate = wxPyBeginAllowThreads();
10699 (arg1)->SetPointSize(arg2);
10700
10701 wxPyEndAllowThreads(__tstate);
10702 if (PyErr_Occurred()) SWIG_fail;
10703 }
10704 Py_INCREF(Py_None); resultobj = Py_None;
10705 return resultobj;
10706 fail:
10707 return NULL;
10708 }
10709
10710
10711 static PyObject *_wrap_Font_SetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10712 PyObject *resultobj;
10713 wxFont *arg1 = (wxFont *) 0 ;
10714 wxSize *arg2 = 0 ;
10715 wxSize temp2 ;
10716 PyObject * obj0 = 0 ;
10717 PyObject * obj1 = 0 ;
10718 char *kwnames[] = {
10719 (char *) "self",(char *) "pixelSize", NULL
10720 };
10721
10722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPixelSize",kwnames,&obj0,&obj1)) goto fail;
10723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10724 if (SWIG_arg_fail(1)) SWIG_fail;
10725 {
10726 arg2 = &temp2;
10727 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
10728 }
10729 {
10730 PyThreadState* __tstate = wxPyBeginAllowThreads();
10731 (arg1)->SetPixelSize((wxSize const &)*arg2);
10732
10733 wxPyEndAllowThreads(__tstate);
10734 if (PyErr_Occurred()) SWIG_fail;
10735 }
10736 Py_INCREF(Py_None); resultobj = Py_None;
10737 return resultobj;
10738 fail:
10739 return NULL;
10740 }
10741
10742
10743 static PyObject *_wrap_Font_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
10744 PyObject *resultobj;
10745 wxFont *arg1 = (wxFont *) 0 ;
10746 int arg2 ;
10747 PyObject * obj0 = 0 ;
10748 PyObject * obj1 = 0 ;
10749 char *kwnames[] = {
10750 (char *) "self",(char *) "family", NULL
10751 };
10752
10753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFamily",kwnames,&obj0,&obj1)) goto fail;
10754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10755 if (SWIG_arg_fail(1)) SWIG_fail;
10756 {
10757 arg2 = (int)(SWIG_As_int(obj1));
10758 if (SWIG_arg_fail(2)) SWIG_fail;
10759 }
10760 {
10761 PyThreadState* __tstate = wxPyBeginAllowThreads();
10762 (arg1)->SetFamily(arg2);
10763
10764 wxPyEndAllowThreads(__tstate);
10765 if (PyErr_Occurred()) SWIG_fail;
10766 }
10767 Py_INCREF(Py_None); resultobj = Py_None;
10768 return resultobj;
10769 fail:
10770 return NULL;
10771 }
10772
10773
10774 static PyObject *_wrap_Font_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10775 PyObject *resultobj;
10776 wxFont *arg1 = (wxFont *) 0 ;
10777 int arg2 ;
10778 PyObject * obj0 = 0 ;
10779 PyObject * obj1 = 0 ;
10780 char *kwnames[] = {
10781 (char *) "self",(char *) "style", NULL
10782 };
10783
10784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetStyle",kwnames,&obj0,&obj1)) goto fail;
10785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10786 if (SWIG_arg_fail(1)) SWIG_fail;
10787 {
10788 arg2 = (int)(SWIG_As_int(obj1));
10789 if (SWIG_arg_fail(2)) SWIG_fail;
10790 }
10791 {
10792 PyThreadState* __tstate = wxPyBeginAllowThreads();
10793 (arg1)->SetStyle(arg2);
10794
10795 wxPyEndAllowThreads(__tstate);
10796 if (PyErr_Occurred()) SWIG_fail;
10797 }
10798 Py_INCREF(Py_None); resultobj = Py_None;
10799 return resultobj;
10800 fail:
10801 return NULL;
10802 }
10803
10804
10805 static PyObject *_wrap_Font_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
10806 PyObject *resultobj;
10807 wxFont *arg1 = (wxFont *) 0 ;
10808 int arg2 ;
10809 PyObject * obj0 = 0 ;
10810 PyObject * obj1 = 0 ;
10811 char *kwnames[] = {
10812 (char *) "self",(char *) "weight", NULL
10813 };
10814
10815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetWeight",kwnames,&obj0,&obj1)) goto fail;
10816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10817 if (SWIG_arg_fail(1)) SWIG_fail;
10818 {
10819 arg2 = (int)(SWIG_As_int(obj1));
10820 if (SWIG_arg_fail(2)) SWIG_fail;
10821 }
10822 {
10823 PyThreadState* __tstate = wxPyBeginAllowThreads();
10824 (arg1)->SetWeight(arg2);
10825
10826 wxPyEndAllowThreads(__tstate);
10827 if (PyErr_Occurred()) SWIG_fail;
10828 }
10829 Py_INCREF(Py_None); resultobj = Py_None;
10830 return resultobj;
10831 fail:
10832 return NULL;
10833 }
10834
10835
10836 static PyObject *_wrap_Font_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
10837 PyObject *resultobj;
10838 wxFont *arg1 = (wxFont *) 0 ;
10839 wxString *arg2 = 0 ;
10840 bool temp2 = false ;
10841 PyObject * obj0 = 0 ;
10842 PyObject * obj1 = 0 ;
10843 char *kwnames[] = {
10844 (char *) "self",(char *) "faceName", NULL
10845 };
10846
10847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
10848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10849 if (SWIG_arg_fail(1)) SWIG_fail;
10850 {
10851 arg2 = wxString_in_helper(obj1);
10852 if (arg2 == NULL) SWIG_fail;
10853 temp2 = true;
10854 }
10855 {
10856 PyThreadState* __tstate = wxPyBeginAllowThreads();
10857 (arg1)->SetFaceName((wxString const &)*arg2);
10858
10859 wxPyEndAllowThreads(__tstate);
10860 if (PyErr_Occurred()) SWIG_fail;
10861 }
10862 Py_INCREF(Py_None); resultobj = Py_None;
10863 {
10864 if (temp2)
10865 delete arg2;
10866 }
10867 return resultobj;
10868 fail:
10869 {
10870 if (temp2)
10871 delete arg2;
10872 }
10873 return NULL;
10874 }
10875
10876
10877 static PyObject *_wrap_Font_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
10878 PyObject *resultobj;
10879 wxFont *arg1 = (wxFont *) 0 ;
10880 bool arg2 ;
10881 PyObject * obj0 = 0 ;
10882 PyObject * obj1 = 0 ;
10883 char *kwnames[] = {
10884 (char *) "self",(char *) "underlined", NULL
10885 };
10886
10887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
10888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10889 if (SWIG_arg_fail(1)) SWIG_fail;
10890 {
10891 arg2 = (bool)(SWIG_As_bool(obj1));
10892 if (SWIG_arg_fail(2)) SWIG_fail;
10893 }
10894 {
10895 PyThreadState* __tstate = wxPyBeginAllowThreads();
10896 (arg1)->SetUnderlined(arg2);
10897
10898 wxPyEndAllowThreads(__tstate);
10899 if (PyErr_Occurred()) SWIG_fail;
10900 }
10901 Py_INCREF(Py_None); resultobj = Py_None;
10902 return resultobj;
10903 fail:
10904 return NULL;
10905 }
10906
10907
10908 static PyObject *_wrap_Font_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10909 PyObject *resultobj;
10910 wxFont *arg1 = (wxFont *) 0 ;
10911 wxFontEncoding arg2 ;
10912 PyObject * obj0 = 0 ;
10913 PyObject * obj1 = 0 ;
10914 char *kwnames[] = {
10915 (char *) "self",(char *) "encoding", NULL
10916 };
10917
10918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
10919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10920 if (SWIG_arg_fail(1)) SWIG_fail;
10921 {
10922 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10923 if (SWIG_arg_fail(2)) SWIG_fail;
10924 }
10925 {
10926 PyThreadState* __tstate = wxPyBeginAllowThreads();
10927 (arg1)->SetEncoding((wxFontEncoding )arg2);
10928
10929 wxPyEndAllowThreads(__tstate);
10930 if (PyErr_Occurred()) SWIG_fail;
10931 }
10932 Py_INCREF(Py_None); resultobj = Py_None;
10933 return resultobj;
10934 fail:
10935 return NULL;
10936 }
10937
10938
10939 static PyObject *_wrap_Font_SetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10940 PyObject *resultobj;
10941 wxFont *arg1 = (wxFont *) 0 ;
10942 wxNativeFontInfo *arg2 = 0 ;
10943 PyObject * obj0 = 0 ;
10944 PyObject * obj1 = 0 ;
10945 char *kwnames[] = {
10946 (char *) "self",(char *) "info", NULL
10947 };
10948
10949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfo",kwnames,&obj0,&obj1)) goto fail;
10950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10951 if (SWIG_arg_fail(1)) SWIG_fail;
10952 {
10953 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
10954 if (SWIG_arg_fail(2)) SWIG_fail;
10955 if (arg2 == NULL) {
10956 SWIG_null_ref("wxNativeFontInfo");
10957 }
10958 if (SWIG_arg_fail(2)) SWIG_fail;
10959 }
10960 {
10961 PyThreadState* __tstate = wxPyBeginAllowThreads();
10962 (arg1)->SetNativeFontInfo((wxNativeFontInfo const &)*arg2);
10963
10964 wxPyEndAllowThreads(__tstate);
10965 if (PyErr_Occurred()) SWIG_fail;
10966 }
10967 Py_INCREF(Py_None); resultobj = Py_None;
10968 return resultobj;
10969 fail:
10970 return NULL;
10971 }
10972
10973
10974 static PyObject *_wrap_Font_SetNativeFontInfoFromString(PyObject *, PyObject *args, PyObject *kwargs) {
10975 PyObject *resultobj;
10976 wxFont *arg1 = (wxFont *) 0 ;
10977 wxString *arg2 = 0 ;
10978 bool temp2 = false ;
10979 PyObject * obj0 = 0 ;
10980 PyObject * obj1 = 0 ;
10981 char *kwnames[] = {
10982 (char *) "self",(char *) "info", NULL
10983 };
10984
10985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoFromString",kwnames,&obj0,&obj1)) goto fail;
10986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10987 if (SWIG_arg_fail(1)) SWIG_fail;
10988 {
10989 arg2 = wxString_in_helper(obj1);
10990 if (arg2 == NULL) SWIG_fail;
10991 temp2 = true;
10992 }
10993 {
10994 PyThreadState* __tstate = wxPyBeginAllowThreads();
10995 (arg1)->SetNativeFontInfo((wxString const &)*arg2);
10996
10997 wxPyEndAllowThreads(__tstate);
10998 if (PyErr_Occurred()) SWIG_fail;
10999 }
11000 Py_INCREF(Py_None); resultobj = Py_None;
11001 {
11002 if (temp2)
11003 delete arg2;
11004 }
11005 return resultobj;
11006 fail:
11007 {
11008 if (temp2)
11009 delete arg2;
11010 }
11011 return NULL;
11012 }
11013
11014
11015 static PyObject *_wrap_Font_SetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
11016 PyObject *resultobj;
11017 wxFont *arg1 = (wxFont *) 0 ;
11018 wxString *arg2 = 0 ;
11019 bool temp2 = false ;
11020 PyObject * obj0 = 0 ;
11021 PyObject * obj1 = 0 ;
11022 char *kwnames[] = {
11023 (char *) "self",(char *) "info", NULL
11024 };
11025
11026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoUserDesc",kwnames,&obj0,&obj1)) goto fail;
11027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11028 if (SWIG_arg_fail(1)) SWIG_fail;
11029 {
11030 arg2 = wxString_in_helper(obj1);
11031 if (arg2 == NULL) SWIG_fail;
11032 temp2 = true;
11033 }
11034 {
11035 PyThreadState* __tstate = wxPyBeginAllowThreads();
11036 (arg1)->SetNativeFontInfoUserDesc((wxString const &)*arg2);
11037
11038 wxPyEndAllowThreads(__tstate);
11039 if (PyErr_Occurred()) SWIG_fail;
11040 }
11041 Py_INCREF(Py_None); resultobj = Py_None;
11042 {
11043 if (temp2)
11044 delete arg2;
11045 }
11046 return resultobj;
11047 fail:
11048 {
11049 if (temp2)
11050 delete arg2;
11051 }
11052 return NULL;
11053 }
11054
11055
11056 static PyObject *_wrap_Font_GetFamilyString(PyObject *, PyObject *args, PyObject *kwargs) {
11057 PyObject *resultobj;
11058 wxFont *arg1 = (wxFont *) 0 ;
11059 wxString result;
11060 PyObject * obj0 = 0 ;
11061 char *kwnames[] = {
11062 (char *) "self", NULL
11063 };
11064
11065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamilyString",kwnames,&obj0)) goto fail;
11066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11067 if (SWIG_arg_fail(1)) SWIG_fail;
11068 {
11069 PyThreadState* __tstate = wxPyBeginAllowThreads();
11070 result = ((wxFont const *)arg1)->GetFamilyString();
11071
11072 wxPyEndAllowThreads(__tstate);
11073 if (PyErr_Occurred()) SWIG_fail;
11074 }
11075 {
11076 #if wxUSE_UNICODE
11077 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11078 #else
11079 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11080 #endif
11081 }
11082 return resultobj;
11083 fail:
11084 return NULL;
11085 }
11086
11087
11088 static PyObject *_wrap_Font_GetStyleString(PyObject *, PyObject *args, PyObject *kwargs) {
11089 PyObject *resultobj;
11090 wxFont *arg1 = (wxFont *) 0 ;
11091 wxString result;
11092 PyObject * obj0 = 0 ;
11093 char *kwnames[] = {
11094 (char *) "self", NULL
11095 };
11096
11097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyleString",kwnames,&obj0)) goto fail;
11098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11099 if (SWIG_arg_fail(1)) SWIG_fail;
11100 {
11101 PyThreadState* __tstate = wxPyBeginAllowThreads();
11102 result = ((wxFont const *)arg1)->GetStyleString();
11103
11104 wxPyEndAllowThreads(__tstate);
11105 if (PyErr_Occurred()) SWIG_fail;
11106 }
11107 {
11108 #if wxUSE_UNICODE
11109 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11110 #else
11111 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11112 #endif
11113 }
11114 return resultobj;
11115 fail:
11116 return NULL;
11117 }
11118
11119
11120 static PyObject *_wrap_Font_GetWeightString(PyObject *, PyObject *args, PyObject *kwargs) {
11121 PyObject *resultobj;
11122 wxFont *arg1 = (wxFont *) 0 ;
11123 wxString result;
11124 PyObject * obj0 = 0 ;
11125 char *kwnames[] = {
11126 (char *) "self", NULL
11127 };
11128
11129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeightString",kwnames,&obj0)) goto fail;
11130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11131 if (SWIG_arg_fail(1)) SWIG_fail;
11132 {
11133 PyThreadState* __tstate = wxPyBeginAllowThreads();
11134 result = ((wxFont const *)arg1)->GetWeightString();
11135
11136 wxPyEndAllowThreads(__tstate);
11137 if (PyErr_Occurred()) SWIG_fail;
11138 }
11139 {
11140 #if wxUSE_UNICODE
11141 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11142 #else
11143 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11144 #endif
11145 }
11146 return resultobj;
11147 fail:
11148 return NULL;
11149 }
11150
11151
11152 static PyObject *_wrap_Font_SetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
11153 PyObject *resultobj;
11154 wxFont *arg1 = (wxFont *) 0 ;
11155 bool arg2 = (bool) true ;
11156 PyObject * obj0 = 0 ;
11157 PyObject * obj1 = 0 ;
11158 char *kwnames[] = {
11159 (char *) "self",(char *) "no", NULL
11160 };
11161
11162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Font_SetNoAntiAliasing",kwnames,&obj0,&obj1)) goto fail;
11163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11164 if (SWIG_arg_fail(1)) SWIG_fail;
11165 if (obj1) {
11166 {
11167 arg2 = (bool)(SWIG_As_bool(obj1));
11168 if (SWIG_arg_fail(2)) SWIG_fail;
11169 }
11170 }
11171 {
11172 PyThreadState* __tstate = wxPyBeginAllowThreads();
11173 (arg1)->SetNoAntiAliasing(arg2);
11174
11175 wxPyEndAllowThreads(__tstate);
11176 if (PyErr_Occurred()) SWIG_fail;
11177 }
11178 Py_INCREF(Py_None); resultobj = Py_None;
11179 return resultobj;
11180 fail:
11181 return NULL;
11182 }
11183
11184
11185 static PyObject *_wrap_Font_GetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
11186 PyObject *resultobj;
11187 wxFont *arg1 = (wxFont *) 0 ;
11188 bool result;
11189 PyObject * obj0 = 0 ;
11190 char *kwnames[] = {
11191 (char *) "self", NULL
11192 };
11193
11194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNoAntiAliasing",kwnames,&obj0)) goto fail;
11195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11196 if (SWIG_arg_fail(1)) SWIG_fail;
11197 {
11198 PyThreadState* __tstate = wxPyBeginAllowThreads();
11199 result = (bool)((wxFont const *)arg1)->GetNoAntiAliasing();
11200
11201 wxPyEndAllowThreads(__tstate);
11202 if (PyErr_Occurred()) SWIG_fail;
11203 }
11204 {
11205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11206 }
11207 return resultobj;
11208 fail:
11209 return NULL;
11210 }
11211
11212
11213 static PyObject *_wrap_Font_GetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11214 PyObject *resultobj;
11215 wxFontEncoding result;
11216 char *kwnames[] = {
11217 NULL
11218 };
11219
11220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Font_GetDefaultEncoding",kwnames)) goto fail;
11221 {
11222 if (!wxPyCheckForApp()) SWIG_fail;
11223 PyThreadState* __tstate = wxPyBeginAllowThreads();
11224 result = (wxFontEncoding)wxFont::GetDefaultEncoding();
11225
11226 wxPyEndAllowThreads(__tstate);
11227 if (PyErr_Occurred()) SWIG_fail;
11228 }
11229 resultobj = SWIG_From_int((result));
11230 return resultobj;
11231 fail:
11232 return NULL;
11233 }
11234
11235
11236 static PyObject *_wrap_Font_SetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11237 PyObject *resultobj;
11238 wxFontEncoding arg1 ;
11239 PyObject * obj0 = 0 ;
11240 char *kwnames[] = {
11241 (char *) "encoding", NULL
11242 };
11243
11244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_SetDefaultEncoding",kwnames,&obj0)) goto fail;
11245 {
11246 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
11247 if (SWIG_arg_fail(1)) SWIG_fail;
11248 }
11249 {
11250 if (!wxPyCheckForApp()) SWIG_fail;
11251 PyThreadState* __tstate = wxPyBeginAllowThreads();
11252 wxFont::SetDefaultEncoding((wxFontEncoding )arg1);
11253
11254 wxPyEndAllowThreads(__tstate);
11255 if (PyErr_Occurred()) SWIG_fail;
11256 }
11257 Py_INCREF(Py_None); resultobj = Py_None;
11258 return resultobj;
11259 fail:
11260 return NULL;
11261 }
11262
11263
11264 static PyObject * Font_swigregister(PyObject *, PyObject *args) {
11265 PyObject *obj;
11266 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11267 SWIG_TypeClientData(SWIGTYPE_p_wxFont, obj);
11268 Py_INCREF(obj);
11269 return Py_BuildValue((char *)"");
11270 }
11271 static PyObject *_wrap_new_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
11272 PyObject *resultobj;
11273 wxPyFontEnumerator *result;
11274 char *kwnames[] = {
11275 NULL
11276 };
11277
11278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontEnumerator",kwnames)) goto fail;
11279 {
11280 if (!wxPyCheckForApp()) SWIG_fail;
11281 PyThreadState* __tstate = wxPyBeginAllowThreads();
11282 result = (wxPyFontEnumerator *)new wxPyFontEnumerator();
11283
11284 wxPyEndAllowThreads(__tstate);
11285 if (PyErr_Occurred()) SWIG_fail;
11286 }
11287 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFontEnumerator, 1);
11288 return resultobj;
11289 fail:
11290 return NULL;
11291 }
11292
11293
11294 static PyObject *_wrap_delete_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
11295 PyObject *resultobj;
11296 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11297 PyObject * obj0 = 0 ;
11298 char *kwnames[] = {
11299 (char *) "self", NULL
11300 };
11301
11302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontEnumerator",kwnames,&obj0)) goto fail;
11303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11304 if (SWIG_arg_fail(1)) SWIG_fail;
11305 {
11306 PyThreadState* __tstate = wxPyBeginAllowThreads();
11307 delete arg1;
11308
11309 wxPyEndAllowThreads(__tstate);
11310 if (PyErr_Occurred()) SWIG_fail;
11311 }
11312 Py_INCREF(Py_None); resultobj = Py_None;
11313 return resultobj;
11314 fail:
11315 return NULL;
11316 }
11317
11318
11319 static PyObject *_wrap_FontEnumerator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11320 PyObject *resultobj;
11321 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11322 PyObject *arg2 = (PyObject *) 0 ;
11323 PyObject *arg3 = (PyObject *) 0 ;
11324 bool arg4 ;
11325 PyObject * obj0 = 0 ;
11326 PyObject * obj1 = 0 ;
11327 PyObject * obj2 = 0 ;
11328 PyObject * obj3 = 0 ;
11329 char *kwnames[] = {
11330 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11331 };
11332
11333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FontEnumerator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11335 if (SWIG_arg_fail(1)) SWIG_fail;
11336 arg2 = obj1;
11337 arg3 = obj2;
11338 {
11339 arg4 = (bool)(SWIG_As_bool(obj3));
11340 if (SWIG_arg_fail(4)) SWIG_fail;
11341 }
11342 {
11343 PyThreadState* __tstate = wxPyBeginAllowThreads();
11344 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11345
11346 wxPyEndAllowThreads(__tstate);
11347 if (PyErr_Occurred()) SWIG_fail;
11348 }
11349 Py_INCREF(Py_None); resultobj = Py_None;
11350 return resultobj;
11351 fail:
11352 return NULL;
11353 }
11354
11355
11356 static PyObject *_wrap_FontEnumerator_EnumerateFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
11357 PyObject *resultobj;
11358 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11359 wxFontEncoding arg2 = (wxFontEncoding) wxFONTENCODING_SYSTEM ;
11360 bool arg3 = (bool) false ;
11361 bool result;
11362 PyObject * obj0 = 0 ;
11363 PyObject * obj1 = 0 ;
11364 PyObject * obj2 = 0 ;
11365 char *kwnames[] = {
11366 (char *) "self",(char *) "encoding",(char *) "fixedWidthOnly", NULL
11367 };
11368
11369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FontEnumerator_EnumerateFacenames",kwnames,&obj0,&obj1,&obj2)) goto fail;
11370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11371 if (SWIG_arg_fail(1)) SWIG_fail;
11372 if (obj1) {
11373 {
11374 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
11375 if (SWIG_arg_fail(2)) SWIG_fail;
11376 }
11377 }
11378 if (obj2) {
11379 {
11380 arg3 = (bool)(SWIG_As_bool(obj2));
11381 if (SWIG_arg_fail(3)) SWIG_fail;
11382 }
11383 }
11384 {
11385 PyThreadState* __tstate = wxPyBeginAllowThreads();
11386 result = (bool)(arg1)->EnumerateFacenames((wxFontEncoding )arg2,arg3);
11387
11388 wxPyEndAllowThreads(__tstate);
11389 if (PyErr_Occurred()) SWIG_fail;
11390 }
11391 {
11392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11393 }
11394 return resultobj;
11395 fail:
11396 return NULL;
11397 }
11398
11399
11400 static PyObject *_wrap_FontEnumerator_EnumerateEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
11401 PyObject *resultobj;
11402 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11403 wxString const &arg2_defvalue = wxPyEmptyString ;
11404 wxString *arg2 = (wxString *) &arg2_defvalue ;
11405 bool result;
11406 bool temp2 = false ;
11407 PyObject * obj0 = 0 ;
11408 PyObject * obj1 = 0 ;
11409 char *kwnames[] = {
11410 (char *) "self",(char *) "facename", NULL
11411 };
11412
11413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FontEnumerator_EnumerateEncodings",kwnames,&obj0,&obj1)) goto fail;
11414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11415 if (SWIG_arg_fail(1)) SWIG_fail;
11416 if (obj1) {
11417 {
11418 arg2 = wxString_in_helper(obj1);
11419 if (arg2 == NULL) SWIG_fail;
11420 temp2 = true;
11421 }
11422 }
11423 {
11424 PyThreadState* __tstate = wxPyBeginAllowThreads();
11425 result = (bool)(arg1)->EnumerateEncodings((wxString const &)*arg2);
11426
11427 wxPyEndAllowThreads(__tstate);
11428 if (PyErr_Occurred()) SWIG_fail;
11429 }
11430 {
11431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11432 }
11433 {
11434 if (temp2)
11435 delete arg2;
11436 }
11437 return resultobj;
11438 fail:
11439 {
11440 if (temp2)
11441 delete arg2;
11442 }
11443 return NULL;
11444 }
11445
11446
11447 static PyObject *_wrap_FontEnumerator_GetEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
11448 PyObject *resultobj;
11449 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11450 PyObject *result;
11451 PyObject * obj0 = 0 ;
11452 char *kwnames[] = {
11453 (char *) "self", NULL
11454 };
11455
11456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetEncodings",kwnames,&obj0)) goto fail;
11457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11458 if (SWIG_arg_fail(1)) SWIG_fail;
11459 {
11460 PyThreadState* __tstate = wxPyBeginAllowThreads();
11461 result = (PyObject *)wxPyFontEnumerator_GetEncodings(arg1);
11462
11463 wxPyEndAllowThreads(__tstate);
11464 if (PyErr_Occurred()) SWIG_fail;
11465 }
11466 resultobj = result;
11467 return resultobj;
11468 fail:
11469 return NULL;
11470 }
11471
11472
11473 static PyObject *_wrap_FontEnumerator_GetFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
11474 PyObject *resultobj;
11475 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11476 PyObject *result;
11477 PyObject * obj0 = 0 ;
11478 char *kwnames[] = {
11479 (char *) "self", NULL
11480 };
11481
11482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetFacenames",kwnames,&obj0)) goto fail;
11483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11484 if (SWIG_arg_fail(1)) SWIG_fail;
11485 {
11486 PyThreadState* __tstate = wxPyBeginAllowThreads();
11487 result = (PyObject *)wxPyFontEnumerator_GetFacenames(arg1);
11488
11489 wxPyEndAllowThreads(__tstate);
11490 if (PyErr_Occurred()) SWIG_fail;
11491 }
11492 resultobj = result;
11493 return resultobj;
11494 fail:
11495 return NULL;
11496 }
11497
11498
11499 static PyObject * FontEnumerator_swigregister(PyObject *, PyObject *args) {
11500 PyObject *obj;
11501 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11502 SWIG_TypeClientData(SWIGTYPE_p_wxPyFontEnumerator, obj);
11503 Py_INCREF(obj);
11504 return Py_BuildValue((char *)"");
11505 }
11506 static PyObject *_wrap_LanguageInfo_Language_set(PyObject *, PyObject *args, PyObject *kwargs) {
11507 PyObject *resultobj;
11508 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11509 int arg2 ;
11510 PyObject * obj0 = 0 ;
11511 PyObject * obj1 = 0 ;
11512 char *kwnames[] = {
11513 (char *) "self",(char *) "Language", NULL
11514 };
11515
11516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Language_set",kwnames,&obj0,&obj1)) goto fail;
11517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11518 if (SWIG_arg_fail(1)) SWIG_fail;
11519 {
11520 arg2 = (int)(SWIG_As_int(obj1));
11521 if (SWIG_arg_fail(2)) SWIG_fail;
11522 }
11523 if (arg1) (arg1)->Language = arg2;
11524
11525 Py_INCREF(Py_None); resultobj = Py_None;
11526 return resultobj;
11527 fail:
11528 return NULL;
11529 }
11530
11531
11532 static PyObject *_wrap_LanguageInfo_Language_get(PyObject *, PyObject *args, PyObject *kwargs) {
11533 PyObject *resultobj;
11534 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11535 int result;
11536 PyObject * obj0 = 0 ;
11537 char *kwnames[] = {
11538 (char *) "self", NULL
11539 };
11540
11541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Language_get",kwnames,&obj0)) goto fail;
11542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11543 if (SWIG_arg_fail(1)) SWIG_fail;
11544 result = (int) ((arg1)->Language);
11545
11546 {
11547 resultobj = SWIG_From_int((int)(result));
11548 }
11549 return resultobj;
11550 fail:
11551 return NULL;
11552 }
11553
11554
11555 static PyObject *_wrap_LanguageInfo_CanonicalName_set(PyObject *, PyObject *args, PyObject *kwargs) {
11556 PyObject *resultobj;
11557 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11558 wxString *arg2 = (wxString *) 0 ;
11559 bool temp2 = false ;
11560 PyObject * obj0 = 0 ;
11561 PyObject * obj1 = 0 ;
11562 char *kwnames[] = {
11563 (char *) "self",(char *) "CanonicalName", NULL
11564 };
11565
11566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_CanonicalName_set",kwnames,&obj0,&obj1)) goto fail;
11567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11568 if (SWIG_arg_fail(1)) SWIG_fail;
11569 {
11570 arg2 = wxString_in_helper(obj1);
11571 if (arg2 == NULL) SWIG_fail;
11572 temp2 = true;
11573 }
11574 if (arg1) (arg1)->CanonicalName = *arg2;
11575
11576 Py_INCREF(Py_None); resultobj = Py_None;
11577 {
11578 if (temp2)
11579 delete arg2;
11580 }
11581 return resultobj;
11582 fail:
11583 {
11584 if (temp2)
11585 delete arg2;
11586 }
11587 return NULL;
11588 }
11589
11590
11591 static PyObject *_wrap_LanguageInfo_CanonicalName_get(PyObject *, PyObject *args, PyObject *kwargs) {
11592 PyObject *resultobj;
11593 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11594 wxString *result;
11595 PyObject * obj0 = 0 ;
11596 char *kwnames[] = {
11597 (char *) "self", NULL
11598 };
11599
11600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_CanonicalName_get",kwnames,&obj0)) goto fail;
11601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11602 if (SWIG_arg_fail(1)) SWIG_fail;
11603 result = (wxString *)& ((arg1)->CanonicalName);
11604
11605 {
11606 #if wxUSE_UNICODE
11607 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11608 #else
11609 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11610 #endif
11611 }
11612 return resultobj;
11613 fail:
11614 return NULL;
11615 }
11616
11617
11618 static PyObject *_wrap_LanguageInfo_Description_set(PyObject *, PyObject *args, PyObject *kwargs) {
11619 PyObject *resultobj;
11620 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11621 wxString *arg2 = (wxString *) 0 ;
11622 bool temp2 = false ;
11623 PyObject * obj0 = 0 ;
11624 PyObject * obj1 = 0 ;
11625 char *kwnames[] = {
11626 (char *) "self",(char *) "Description", NULL
11627 };
11628
11629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Description_set",kwnames,&obj0,&obj1)) goto fail;
11630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11631 if (SWIG_arg_fail(1)) SWIG_fail;
11632 {
11633 arg2 = wxString_in_helper(obj1);
11634 if (arg2 == NULL) SWIG_fail;
11635 temp2 = true;
11636 }
11637 if (arg1) (arg1)->Description = *arg2;
11638
11639 Py_INCREF(Py_None); resultobj = Py_None;
11640 {
11641 if (temp2)
11642 delete arg2;
11643 }
11644 return resultobj;
11645 fail:
11646 {
11647 if (temp2)
11648 delete arg2;
11649 }
11650 return NULL;
11651 }
11652
11653
11654 static PyObject *_wrap_LanguageInfo_Description_get(PyObject *, PyObject *args, PyObject *kwargs) {
11655 PyObject *resultobj;
11656 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11657 wxString *result;
11658 PyObject * obj0 = 0 ;
11659 char *kwnames[] = {
11660 (char *) "self", NULL
11661 };
11662
11663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Description_get",kwnames,&obj0)) goto fail;
11664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11665 if (SWIG_arg_fail(1)) SWIG_fail;
11666 result = (wxString *)& ((arg1)->Description);
11667
11668 {
11669 #if wxUSE_UNICODE
11670 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11671 #else
11672 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11673 #endif
11674 }
11675 return resultobj;
11676 fail:
11677 return NULL;
11678 }
11679
11680
11681 static PyObject * LanguageInfo_swigregister(PyObject *, PyObject *args) {
11682 PyObject *obj;
11683 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11684 SWIG_TypeClientData(SWIGTYPE_p_wxLanguageInfo, obj);
11685 Py_INCREF(obj);
11686 return Py_BuildValue((char *)"");
11687 }
11688 static PyObject *_wrap_new_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11689 PyObject *resultobj;
11690 int arg1 = (int) -1 ;
11691 int arg2 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11692 wxLocale *result;
11693 PyObject * obj0 = 0 ;
11694 PyObject * obj1 = 0 ;
11695 char *kwnames[] = {
11696 (char *) "language",(char *) "flags", NULL
11697 };
11698
11699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Locale",kwnames,&obj0,&obj1)) goto fail;
11700 if (obj0) {
11701 {
11702 arg1 = (int)(SWIG_As_int(obj0));
11703 if (SWIG_arg_fail(1)) SWIG_fail;
11704 }
11705 }
11706 if (obj1) {
11707 {
11708 arg2 = (int)(SWIG_As_int(obj1));
11709 if (SWIG_arg_fail(2)) SWIG_fail;
11710 }
11711 }
11712 {
11713 PyThreadState* __tstate = wxPyBeginAllowThreads();
11714 result = (wxLocale *)new_wxLocale(arg1,arg2);
11715
11716 wxPyEndAllowThreads(__tstate);
11717 if (PyErr_Occurred()) SWIG_fail;
11718 }
11719 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 1);
11720 return resultobj;
11721 fail:
11722 return NULL;
11723 }
11724
11725
11726 static PyObject *_wrap_delete_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11727 PyObject *resultobj;
11728 wxLocale *arg1 = (wxLocale *) 0 ;
11729 PyObject * obj0 = 0 ;
11730 char *kwnames[] = {
11731 (char *) "self", NULL
11732 };
11733
11734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Locale",kwnames,&obj0)) goto fail;
11735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11736 if (SWIG_arg_fail(1)) SWIG_fail;
11737 {
11738 PyThreadState* __tstate = wxPyBeginAllowThreads();
11739 delete arg1;
11740
11741 wxPyEndAllowThreads(__tstate);
11742 if (PyErr_Occurred()) SWIG_fail;
11743 }
11744 Py_INCREF(Py_None); resultobj = Py_None;
11745 return resultobj;
11746 fail:
11747 return NULL;
11748 }
11749
11750
11751 static PyObject *_wrap_Locale_Init1(PyObject *, PyObject *args, PyObject *kwargs) {
11752 PyObject *resultobj;
11753 wxLocale *arg1 = (wxLocale *) 0 ;
11754 wxString *arg2 = 0 ;
11755 wxString const &arg3_defvalue = wxPyEmptyString ;
11756 wxString *arg3 = (wxString *) &arg3_defvalue ;
11757 wxString const &arg4_defvalue = wxPyEmptyString ;
11758 wxString *arg4 = (wxString *) &arg4_defvalue ;
11759 bool arg5 = (bool) true ;
11760 bool arg6 = (bool) false ;
11761 bool result;
11762 bool temp2 = false ;
11763 bool temp3 = false ;
11764 bool temp4 = false ;
11765 PyObject * obj0 = 0 ;
11766 PyObject * obj1 = 0 ;
11767 PyObject * obj2 = 0 ;
11768 PyObject * obj3 = 0 ;
11769 PyObject * obj4 = 0 ;
11770 PyObject * obj5 = 0 ;
11771 char *kwnames[] = {
11772 (char *) "self",(char *) "szName",(char *) "szShort",(char *) "szLocale",(char *) "bLoadDefault",(char *) "bConvertEncoding", NULL
11773 };
11774
11775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Locale_Init1",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11777 if (SWIG_arg_fail(1)) SWIG_fail;
11778 {
11779 arg2 = wxString_in_helper(obj1);
11780 if (arg2 == NULL) SWIG_fail;
11781 temp2 = true;
11782 }
11783 if (obj2) {
11784 {
11785 arg3 = wxString_in_helper(obj2);
11786 if (arg3 == NULL) SWIG_fail;
11787 temp3 = true;
11788 }
11789 }
11790 if (obj3) {
11791 {
11792 arg4 = wxString_in_helper(obj3);
11793 if (arg4 == NULL) SWIG_fail;
11794 temp4 = true;
11795 }
11796 }
11797 if (obj4) {
11798 {
11799 arg5 = (bool)(SWIG_As_bool(obj4));
11800 if (SWIG_arg_fail(5)) SWIG_fail;
11801 }
11802 }
11803 if (obj5) {
11804 {
11805 arg6 = (bool)(SWIG_As_bool(obj5));
11806 if (SWIG_arg_fail(6)) SWIG_fail;
11807 }
11808 }
11809 {
11810 PyThreadState* __tstate = wxPyBeginAllowThreads();
11811 result = (bool)wxLocale_Init1(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
11812
11813 wxPyEndAllowThreads(__tstate);
11814 if (PyErr_Occurred()) SWIG_fail;
11815 }
11816 {
11817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11818 }
11819 {
11820 if (temp2)
11821 delete arg2;
11822 }
11823 {
11824 if (temp3)
11825 delete arg3;
11826 }
11827 {
11828 if (temp4)
11829 delete arg4;
11830 }
11831 return resultobj;
11832 fail:
11833 {
11834 if (temp2)
11835 delete arg2;
11836 }
11837 {
11838 if (temp3)
11839 delete arg3;
11840 }
11841 {
11842 if (temp4)
11843 delete arg4;
11844 }
11845 return NULL;
11846 }
11847
11848
11849 static PyObject *_wrap_Locale_Init2(PyObject *, PyObject *args, PyObject *kwargs) {
11850 PyObject *resultobj;
11851 wxLocale *arg1 = (wxLocale *) 0 ;
11852 int arg2 = (int) wxLANGUAGE_DEFAULT ;
11853 int arg3 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11854 bool result;
11855 PyObject * obj0 = 0 ;
11856 PyObject * obj1 = 0 ;
11857 PyObject * obj2 = 0 ;
11858 char *kwnames[] = {
11859 (char *) "self",(char *) "language",(char *) "flags", NULL
11860 };
11861
11862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Locale_Init2",kwnames,&obj0,&obj1,&obj2)) goto fail;
11863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11864 if (SWIG_arg_fail(1)) SWIG_fail;
11865 if (obj1) {
11866 {
11867 arg2 = (int)(SWIG_As_int(obj1));
11868 if (SWIG_arg_fail(2)) SWIG_fail;
11869 }
11870 }
11871 if (obj2) {
11872 {
11873 arg3 = (int)(SWIG_As_int(obj2));
11874 if (SWIG_arg_fail(3)) SWIG_fail;
11875 }
11876 }
11877 {
11878 PyThreadState* __tstate = wxPyBeginAllowThreads();
11879 result = (bool)wxLocale_Init2(arg1,arg2,arg3);
11880
11881 wxPyEndAllowThreads(__tstate);
11882 if (PyErr_Occurred()) SWIG_fail;
11883 }
11884 {
11885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11886 }
11887 return resultobj;
11888 fail:
11889 return NULL;
11890 }
11891
11892
11893 static PyObject *_wrap_Locale_GetSystemLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11894 PyObject *resultobj;
11895 int result;
11896 char *kwnames[] = {
11897 NULL
11898 };
11899
11900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemLanguage",kwnames)) goto fail;
11901 {
11902 PyThreadState* __tstate = wxPyBeginAllowThreads();
11903 result = (int)wxLocale::GetSystemLanguage();
11904
11905 wxPyEndAllowThreads(__tstate);
11906 if (PyErr_Occurred()) SWIG_fail;
11907 }
11908 {
11909 resultobj = SWIG_From_int((int)(result));
11910 }
11911 return resultobj;
11912 fail:
11913 return NULL;
11914 }
11915
11916
11917 static PyObject *_wrap_Locale_GetSystemEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11918 PyObject *resultobj;
11919 wxFontEncoding result;
11920 char *kwnames[] = {
11921 NULL
11922 };
11923
11924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncoding",kwnames)) goto fail;
11925 {
11926 PyThreadState* __tstate = wxPyBeginAllowThreads();
11927 result = (wxFontEncoding)wxLocale::GetSystemEncoding();
11928
11929 wxPyEndAllowThreads(__tstate);
11930 if (PyErr_Occurred()) SWIG_fail;
11931 }
11932 resultobj = SWIG_From_int((result));
11933 return resultobj;
11934 fail:
11935 return NULL;
11936 }
11937
11938
11939 static PyObject *_wrap_Locale_GetSystemEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
11940 PyObject *resultobj;
11941 wxString result;
11942 char *kwnames[] = {
11943 NULL
11944 };
11945
11946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncodingName",kwnames)) goto fail;
11947 {
11948 PyThreadState* __tstate = wxPyBeginAllowThreads();
11949 result = wxLocale::GetSystemEncodingName();
11950
11951 wxPyEndAllowThreads(__tstate);
11952 if (PyErr_Occurred()) SWIG_fail;
11953 }
11954 {
11955 #if wxUSE_UNICODE
11956 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11957 #else
11958 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11959 #endif
11960 }
11961 return resultobj;
11962 fail:
11963 return NULL;
11964 }
11965
11966
11967 static PyObject *_wrap_Locale_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11968 PyObject *resultobj;
11969 wxLocale *arg1 = (wxLocale *) 0 ;
11970 bool result;
11971 PyObject * obj0 = 0 ;
11972 char *kwnames[] = {
11973 (char *) "self", NULL
11974 };
11975
11976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_IsOk",kwnames,&obj0)) goto fail;
11977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11978 if (SWIG_arg_fail(1)) SWIG_fail;
11979 {
11980 PyThreadState* __tstate = wxPyBeginAllowThreads();
11981 result = (bool)((wxLocale const *)arg1)->IsOk();
11982
11983 wxPyEndAllowThreads(__tstate);
11984 if (PyErr_Occurred()) SWIG_fail;
11985 }
11986 {
11987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11988 }
11989 return resultobj;
11990 fail:
11991 return NULL;
11992 }
11993
11994
11995 static PyObject *_wrap_Locale_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11996 PyObject *resultobj;
11997 wxLocale *arg1 = (wxLocale *) 0 ;
11998 wxString result;
11999 PyObject * obj0 = 0 ;
12000 char *kwnames[] = {
12001 (char *) "self", NULL
12002 };
12003
12004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLocale",kwnames,&obj0)) goto fail;
12005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12006 if (SWIG_arg_fail(1)) SWIG_fail;
12007 {
12008 PyThreadState* __tstate = wxPyBeginAllowThreads();
12009 result = ((wxLocale const *)arg1)->GetLocale();
12010
12011 wxPyEndAllowThreads(__tstate);
12012 if (PyErr_Occurred()) SWIG_fail;
12013 }
12014 {
12015 #if wxUSE_UNICODE
12016 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12017 #else
12018 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12019 #endif
12020 }
12021 return resultobj;
12022 fail:
12023 return NULL;
12024 }
12025
12026
12027 static PyObject *_wrap_Locale_GetLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
12028 PyObject *resultobj;
12029 wxLocale *arg1 = (wxLocale *) 0 ;
12030 int result;
12031 PyObject * obj0 = 0 ;
12032 char *kwnames[] = {
12033 (char *) "self", NULL
12034 };
12035
12036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguage",kwnames,&obj0)) goto fail;
12037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12038 if (SWIG_arg_fail(1)) SWIG_fail;
12039 {
12040 PyThreadState* __tstate = wxPyBeginAllowThreads();
12041 result = (int)((wxLocale const *)arg1)->GetLanguage();
12042
12043 wxPyEndAllowThreads(__tstate);
12044 if (PyErr_Occurred()) SWIG_fail;
12045 }
12046 {
12047 resultobj = SWIG_From_int((int)(result));
12048 }
12049 return resultobj;
12050 fail:
12051 return NULL;
12052 }
12053
12054
12055 static PyObject *_wrap_Locale_GetSysName(PyObject *, PyObject *args, PyObject *kwargs) {
12056 PyObject *resultobj;
12057 wxLocale *arg1 = (wxLocale *) 0 ;
12058 wxString result;
12059 PyObject * obj0 = 0 ;
12060 char *kwnames[] = {
12061 (char *) "self", NULL
12062 };
12063
12064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetSysName",kwnames,&obj0)) goto fail;
12065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12066 if (SWIG_arg_fail(1)) SWIG_fail;
12067 {
12068 PyThreadState* __tstate = wxPyBeginAllowThreads();
12069 result = ((wxLocale const *)arg1)->GetSysName();
12070
12071 wxPyEndAllowThreads(__tstate);
12072 if (PyErr_Occurred()) SWIG_fail;
12073 }
12074 {
12075 #if wxUSE_UNICODE
12076 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12077 #else
12078 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12079 #endif
12080 }
12081 return resultobj;
12082 fail:
12083 return NULL;
12084 }
12085
12086
12087 static PyObject *_wrap_Locale_GetCanonicalName(PyObject *, PyObject *args, PyObject *kwargs) {
12088 PyObject *resultobj;
12089 wxLocale *arg1 = (wxLocale *) 0 ;
12090 wxString result;
12091 PyObject * obj0 = 0 ;
12092 char *kwnames[] = {
12093 (char *) "self", NULL
12094 };
12095
12096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetCanonicalName",kwnames,&obj0)) goto fail;
12097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12098 if (SWIG_arg_fail(1)) SWIG_fail;
12099 {
12100 PyThreadState* __tstate = wxPyBeginAllowThreads();
12101 result = ((wxLocale const *)arg1)->GetCanonicalName();
12102
12103 wxPyEndAllowThreads(__tstate);
12104 if (PyErr_Occurred()) SWIG_fail;
12105 }
12106 {
12107 #if wxUSE_UNICODE
12108 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12109 #else
12110 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12111 #endif
12112 }
12113 return resultobj;
12114 fail:
12115 return NULL;
12116 }
12117
12118
12119 static PyObject *_wrap_Locale_AddCatalogLookupPathPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
12120 PyObject *resultobj;
12121 wxString *arg1 = 0 ;
12122 bool temp1 = false ;
12123 PyObject * obj0 = 0 ;
12124 char *kwnames[] = {
12125 (char *) "prefix", NULL
12126 };
12127
12128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddCatalogLookupPathPrefix",kwnames,&obj0)) goto fail;
12129 {
12130 arg1 = wxString_in_helper(obj0);
12131 if (arg1 == NULL) SWIG_fail;
12132 temp1 = true;
12133 }
12134 {
12135 PyThreadState* __tstate = wxPyBeginAllowThreads();
12136 wxLocale::AddCatalogLookupPathPrefix((wxString const &)*arg1);
12137
12138 wxPyEndAllowThreads(__tstate);
12139 if (PyErr_Occurred()) SWIG_fail;
12140 }
12141 Py_INCREF(Py_None); resultobj = Py_None;
12142 {
12143 if (temp1)
12144 delete arg1;
12145 }
12146 return resultobj;
12147 fail:
12148 {
12149 if (temp1)
12150 delete arg1;
12151 }
12152 return NULL;
12153 }
12154
12155
12156 static PyObject *_wrap_Locale_AddCatalog(PyObject *, PyObject *args, PyObject *kwargs) {
12157 PyObject *resultobj;
12158 wxLocale *arg1 = (wxLocale *) 0 ;
12159 wxString *arg2 = 0 ;
12160 bool result;
12161 bool temp2 = false ;
12162 PyObject * obj0 = 0 ;
12163 PyObject * obj1 = 0 ;
12164 char *kwnames[] = {
12165 (char *) "self",(char *) "szDomain", NULL
12166 };
12167
12168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_AddCatalog",kwnames,&obj0,&obj1)) goto fail;
12169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12170 if (SWIG_arg_fail(1)) SWIG_fail;
12171 {
12172 arg2 = wxString_in_helper(obj1);
12173 if (arg2 == NULL) SWIG_fail;
12174 temp2 = true;
12175 }
12176 {
12177 PyThreadState* __tstate = wxPyBeginAllowThreads();
12178 result = (bool)(arg1)->AddCatalog((wxString const &)*arg2);
12179
12180 wxPyEndAllowThreads(__tstate);
12181 if (PyErr_Occurred()) SWIG_fail;
12182 }
12183 {
12184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12185 }
12186 {
12187 if (temp2)
12188 delete arg2;
12189 }
12190 return resultobj;
12191 fail:
12192 {
12193 if (temp2)
12194 delete arg2;
12195 }
12196 return NULL;
12197 }
12198
12199
12200 static PyObject *_wrap_Locale_IsLoaded(PyObject *, PyObject *args, PyObject *kwargs) {
12201 PyObject *resultobj;
12202 wxLocale *arg1 = (wxLocale *) 0 ;
12203 wxString *arg2 = 0 ;
12204 bool result;
12205 bool temp2 = false ;
12206 PyObject * obj0 = 0 ;
12207 PyObject * obj1 = 0 ;
12208 char *kwnames[] = {
12209 (char *) "self",(char *) "szDomain", NULL
12210 };
12211
12212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_IsLoaded",kwnames,&obj0,&obj1)) goto fail;
12213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12214 if (SWIG_arg_fail(1)) SWIG_fail;
12215 {
12216 arg2 = wxString_in_helper(obj1);
12217 if (arg2 == NULL) SWIG_fail;
12218 temp2 = true;
12219 }
12220 {
12221 PyThreadState* __tstate = wxPyBeginAllowThreads();
12222 result = (bool)((wxLocale const *)arg1)->IsLoaded((wxString const &)*arg2);
12223
12224 wxPyEndAllowThreads(__tstate);
12225 if (PyErr_Occurred()) SWIG_fail;
12226 }
12227 {
12228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12229 }
12230 {
12231 if (temp2)
12232 delete arg2;
12233 }
12234 return resultobj;
12235 fail:
12236 {
12237 if (temp2)
12238 delete arg2;
12239 }
12240 return NULL;
12241 }
12242
12243
12244 static PyObject *_wrap_Locale_GetLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
12245 PyObject *resultobj;
12246 int arg1 ;
12247 wxLanguageInfo *result;
12248 PyObject * obj0 = 0 ;
12249 char *kwnames[] = {
12250 (char *) "lang", NULL
12251 };
12252
12253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageInfo",kwnames,&obj0)) goto fail;
12254 {
12255 arg1 = (int)(SWIG_As_int(obj0));
12256 if (SWIG_arg_fail(1)) SWIG_fail;
12257 }
12258 {
12259 PyThreadState* __tstate = wxPyBeginAllowThreads();
12260 result = (wxLanguageInfo *)wxLocale::GetLanguageInfo(arg1);
12261
12262 wxPyEndAllowThreads(__tstate);
12263 if (PyErr_Occurred()) SWIG_fail;
12264 }
12265 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
12266 return resultobj;
12267 fail:
12268 return NULL;
12269 }
12270
12271
12272 static PyObject *_wrap_Locale_GetLanguageName(PyObject *, PyObject *args, PyObject *kwargs) {
12273 PyObject *resultobj;
12274 int arg1 ;
12275 wxString result;
12276 PyObject * obj0 = 0 ;
12277 char *kwnames[] = {
12278 (char *) "lang", NULL
12279 };
12280
12281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageName",kwnames,&obj0)) goto fail;
12282 {
12283 arg1 = (int)(SWIG_As_int(obj0));
12284 if (SWIG_arg_fail(1)) SWIG_fail;
12285 }
12286 {
12287 PyThreadState* __tstate = wxPyBeginAllowThreads();
12288 result = wxLocale::GetLanguageName(arg1);
12289
12290 wxPyEndAllowThreads(__tstate);
12291 if (PyErr_Occurred()) SWIG_fail;
12292 }
12293 {
12294 #if wxUSE_UNICODE
12295 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12296 #else
12297 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12298 #endif
12299 }
12300 return resultobj;
12301 fail:
12302 return NULL;
12303 }
12304
12305
12306 static PyObject *_wrap_Locale_FindLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
12307 PyObject *resultobj;
12308 wxString *arg1 = 0 ;
12309 wxLanguageInfo *result;
12310 bool temp1 = false ;
12311 PyObject * obj0 = 0 ;
12312 char *kwnames[] = {
12313 (char *) "locale", NULL
12314 };
12315
12316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_FindLanguageInfo",kwnames,&obj0)) goto fail;
12317 {
12318 arg1 = wxString_in_helper(obj0);
12319 if (arg1 == NULL) SWIG_fail;
12320 temp1 = true;
12321 }
12322 {
12323 PyThreadState* __tstate = wxPyBeginAllowThreads();
12324 result = (wxLanguageInfo *)wxLocale::FindLanguageInfo((wxString const &)*arg1);
12325
12326 wxPyEndAllowThreads(__tstate);
12327 if (PyErr_Occurred()) SWIG_fail;
12328 }
12329 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
12330 {
12331 if (temp1)
12332 delete arg1;
12333 }
12334 return resultobj;
12335 fail:
12336 {
12337 if (temp1)
12338 delete arg1;
12339 }
12340 return NULL;
12341 }
12342
12343
12344 static PyObject *_wrap_Locale_AddLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
12345 PyObject *resultobj;
12346 wxLanguageInfo *arg1 = 0 ;
12347 PyObject * obj0 = 0 ;
12348 char *kwnames[] = {
12349 (char *) "info", NULL
12350 };
12351
12352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddLanguage",kwnames,&obj0)) goto fail;
12353 {
12354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
12355 if (SWIG_arg_fail(1)) SWIG_fail;
12356 if (arg1 == NULL) {
12357 SWIG_null_ref("wxLanguageInfo");
12358 }
12359 if (SWIG_arg_fail(1)) SWIG_fail;
12360 }
12361 {
12362 PyThreadState* __tstate = wxPyBeginAllowThreads();
12363 wxLocale::AddLanguage((wxLanguageInfo const &)*arg1);
12364
12365 wxPyEndAllowThreads(__tstate);
12366 if (PyErr_Occurred()) SWIG_fail;
12367 }
12368 Py_INCREF(Py_None); resultobj = Py_None;
12369 return resultobj;
12370 fail:
12371 return NULL;
12372 }
12373
12374
12375 static PyObject *_wrap_Locale_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
12376 PyObject *resultobj;
12377 wxLocale *arg1 = (wxLocale *) 0 ;
12378 wxString *arg2 = 0 ;
12379 wxString const &arg3_defvalue = wxPyEmptyString ;
12380 wxString *arg3 = (wxString *) &arg3_defvalue ;
12381 wxString result;
12382 bool temp2 = false ;
12383 bool temp3 = false ;
12384 PyObject * obj0 = 0 ;
12385 PyObject * obj1 = 0 ;
12386 PyObject * obj2 = 0 ;
12387 char *kwnames[] = {
12388 (char *) "self",(char *) "szOrigString",(char *) "szDomain", NULL
12389 };
12390
12391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Locale_GetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
12392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12393 if (SWIG_arg_fail(1)) SWIG_fail;
12394 {
12395 arg2 = wxString_in_helper(obj1);
12396 if (arg2 == NULL) SWIG_fail;
12397 temp2 = true;
12398 }
12399 if (obj2) {
12400 {
12401 arg3 = wxString_in_helper(obj2);
12402 if (arg3 == NULL) SWIG_fail;
12403 temp3 = true;
12404 }
12405 }
12406 {
12407 PyThreadState* __tstate = wxPyBeginAllowThreads();
12408 result = ((wxLocale const *)arg1)->GetString((wxString const &)*arg2,(wxString const &)*arg3);
12409
12410 wxPyEndAllowThreads(__tstate);
12411 if (PyErr_Occurred()) SWIG_fail;
12412 }
12413 {
12414 #if wxUSE_UNICODE
12415 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12416 #else
12417 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12418 #endif
12419 }
12420 {
12421 if (temp2)
12422 delete arg2;
12423 }
12424 {
12425 if (temp3)
12426 delete arg3;
12427 }
12428 return resultobj;
12429 fail:
12430 {
12431 if (temp2)
12432 delete arg2;
12433 }
12434 {
12435 if (temp3)
12436 delete arg3;
12437 }
12438 return NULL;
12439 }
12440
12441
12442 static PyObject *_wrap_Locale_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
12443 PyObject *resultobj;
12444 wxLocale *arg1 = (wxLocale *) 0 ;
12445 wxString *result;
12446 PyObject * obj0 = 0 ;
12447 char *kwnames[] = {
12448 (char *) "self", NULL
12449 };
12450
12451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetName",kwnames,&obj0)) goto fail;
12452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12453 if (SWIG_arg_fail(1)) SWIG_fail;
12454 {
12455 PyThreadState* __tstate = wxPyBeginAllowThreads();
12456 {
12457 wxString const &_result_ref = ((wxLocale const *)arg1)->GetName();
12458 result = (wxString *) &_result_ref;
12459 }
12460
12461 wxPyEndAllowThreads(__tstate);
12462 if (PyErr_Occurred()) SWIG_fail;
12463 }
12464 {
12465 #if wxUSE_UNICODE
12466 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12467 #else
12468 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12469 #endif
12470 }
12471 return resultobj;
12472 fail:
12473 return NULL;
12474 }
12475
12476
12477 static PyObject * Locale_swigregister(PyObject *, PyObject *args) {
12478 PyObject *obj;
12479 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12480 SWIG_TypeClientData(SWIGTYPE_p_wxLocale, obj);
12481 Py_INCREF(obj);
12482 return Py_BuildValue((char *)"");
12483 }
12484 static PyObject *_wrap_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
12485 PyObject *resultobj;
12486 wxLocale *result;
12487 char *kwnames[] = {
12488 NULL
12489 };
12490
12491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocale",kwnames)) goto fail;
12492 {
12493 PyThreadState* __tstate = wxPyBeginAllowThreads();
12494 result = (wxLocale *)wxGetLocale();
12495
12496 wxPyEndAllowThreads(__tstate);
12497 if (PyErr_Occurred()) SWIG_fail;
12498 }
12499 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 0);
12500 return resultobj;
12501 fail:
12502 return NULL;
12503 }
12504
12505
12506 static PyObject *_wrap_GetTranslation__SWIG_0(PyObject *, PyObject *args) {
12507 PyObject *resultobj;
12508 wxString *arg1 = 0 ;
12509 wxString result;
12510 bool temp1 = false ;
12511 PyObject * obj0 = 0 ;
12512
12513 if(!PyArg_ParseTuple(args,(char *)"O:GetTranslation",&obj0)) goto fail;
12514 {
12515 arg1 = wxString_in_helper(obj0);
12516 if (arg1 == NULL) SWIG_fail;
12517 temp1 = true;
12518 }
12519 {
12520 PyThreadState* __tstate = wxPyBeginAllowThreads();
12521 result = wxGetTranslation((wxString const &)*arg1);
12522
12523 wxPyEndAllowThreads(__tstate);
12524 if (PyErr_Occurred()) SWIG_fail;
12525 }
12526 {
12527 #if wxUSE_UNICODE
12528 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12529 #else
12530 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12531 #endif
12532 }
12533 {
12534 if (temp1)
12535 delete arg1;
12536 }
12537 return resultobj;
12538 fail:
12539 {
12540 if (temp1)
12541 delete arg1;
12542 }
12543 return NULL;
12544 }
12545
12546
12547 static PyObject *_wrap_GetTranslation__SWIG_1(PyObject *, PyObject *args) {
12548 PyObject *resultobj;
12549 wxString *arg1 = 0 ;
12550 wxString *arg2 = 0 ;
12551 size_t arg3 ;
12552 wxString result;
12553 bool temp1 = false ;
12554 bool temp2 = false ;
12555 PyObject * obj0 = 0 ;
12556 PyObject * obj1 = 0 ;
12557 PyObject * obj2 = 0 ;
12558
12559 if(!PyArg_ParseTuple(args,(char *)"OOO:GetTranslation",&obj0,&obj1,&obj2)) goto fail;
12560 {
12561 arg1 = wxString_in_helper(obj0);
12562 if (arg1 == NULL) SWIG_fail;
12563 temp1 = true;
12564 }
12565 {
12566 arg2 = wxString_in_helper(obj1);
12567 if (arg2 == NULL) SWIG_fail;
12568 temp2 = true;
12569 }
12570 {
12571 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
12572 if (SWIG_arg_fail(3)) SWIG_fail;
12573 }
12574 {
12575 PyThreadState* __tstate = wxPyBeginAllowThreads();
12576 result = wxGetTranslation((wxString const &)*arg1,(wxString const &)*arg2,arg3);
12577
12578 wxPyEndAllowThreads(__tstate);
12579 if (PyErr_Occurred()) SWIG_fail;
12580 }
12581 {
12582 #if wxUSE_UNICODE
12583 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12584 #else
12585 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12586 #endif
12587 }
12588 {
12589 if (temp1)
12590 delete arg1;
12591 }
12592 {
12593 if (temp2)
12594 delete arg2;
12595 }
12596 return resultobj;
12597 fail:
12598 {
12599 if (temp1)
12600 delete arg1;
12601 }
12602 {
12603 if (temp2)
12604 delete arg2;
12605 }
12606 return NULL;
12607 }
12608
12609
12610 static PyObject *_wrap_GetTranslation(PyObject *self, PyObject *args) {
12611 int argc;
12612 PyObject *argv[4];
12613 int ii;
12614
12615 argc = PyObject_Length(args);
12616 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
12617 argv[ii] = PyTuple_GetItem(args,ii);
12618 }
12619 if (argc == 1) {
12620 int _v;
12621 {
12622 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12623 }
12624 if (_v) {
12625 return _wrap_GetTranslation__SWIG_0(self,args);
12626 }
12627 }
12628 if (argc == 3) {
12629 int _v;
12630 {
12631 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12632 }
12633 if (_v) {
12634 {
12635 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
12636 }
12637 if (_v) {
12638 _v = SWIG_Check_unsigned_SS_long(argv[2]);
12639 if (_v) {
12640 return _wrap_GetTranslation__SWIG_1(self,args);
12641 }
12642 }
12643 }
12644 }
12645
12646 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GetTranslation'");
12647 return NULL;
12648 }
12649
12650
12651 static PyObject *_wrap_new_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
12652 PyObject *resultobj;
12653 wxEncodingConverter *result;
12654 char *kwnames[] = {
12655 NULL
12656 };
12657
12658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EncodingConverter",kwnames)) goto fail;
12659 {
12660 PyThreadState* __tstate = wxPyBeginAllowThreads();
12661 result = (wxEncodingConverter *)new wxEncodingConverter();
12662
12663 wxPyEndAllowThreads(__tstate);
12664 if (PyErr_Occurred()) SWIG_fail;
12665 }
12666 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEncodingConverter, 1);
12667 return resultobj;
12668 fail:
12669 return NULL;
12670 }
12671
12672
12673 static PyObject *_wrap_delete_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
12674 PyObject *resultobj;
12675 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12676 PyObject * obj0 = 0 ;
12677 char *kwnames[] = {
12678 (char *) "self", NULL
12679 };
12680
12681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EncodingConverter",kwnames,&obj0)) goto fail;
12682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12683 if (SWIG_arg_fail(1)) SWIG_fail;
12684 {
12685 PyThreadState* __tstate = wxPyBeginAllowThreads();
12686 delete arg1;
12687
12688 wxPyEndAllowThreads(__tstate);
12689 if (PyErr_Occurred()) SWIG_fail;
12690 }
12691 Py_INCREF(Py_None); resultobj = Py_None;
12692 return resultobj;
12693 fail:
12694 return NULL;
12695 }
12696
12697
12698 static PyObject *_wrap_EncodingConverter_Init(PyObject *, PyObject *args, PyObject *kwargs) {
12699 PyObject *resultobj;
12700 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12701 wxFontEncoding arg2 ;
12702 wxFontEncoding arg3 ;
12703 int arg4 = (int) wxCONVERT_STRICT ;
12704 bool result;
12705 PyObject * obj0 = 0 ;
12706 PyObject * obj1 = 0 ;
12707 PyObject * obj2 = 0 ;
12708 PyObject * obj3 = 0 ;
12709 char *kwnames[] = {
12710 (char *) "self",(char *) "input_enc",(char *) "output_enc",(char *) "method", NULL
12711 };
12712
12713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:EncodingConverter_Init",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12715 if (SWIG_arg_fail(1)) SWIG_fail;
12716 {
12717 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12718 if (SWIG_arg_fail(2)) SWIG_fail;
12719 }
12720 {
12721 arg3 = (wxFontEncoding)(SWIG_As_int(obj2));
12722 if (SWIG_arg_fail(3)) SWIG_fail;
12723 }
12724 if (obj3) {
12725 {
12726 arg4 = (int)(SWIG_As_int(obj3));
12727 if (SWIG_arg_fail(4)) SWIG_fail;
12728 }
12729 }
12730 {
12731 PyThreadState* __tstate = wxPyBeginAllowThreads();
12732 result = (bool)(arg1)->Init((wxFontEncoding )arg2,(wxFontEncoding )arg3,arg4);
12733
12734 wxPyEndAllowThreads(__tstate);
12735 if (PyErr_Occurred()) SWIG_fail;
12736 }
12737 {
12738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12739 }
12740 return resultobj;
12741 fail:
12742 return NULL;
12743 }
12744
12745
12746 static PyObject *_wrap_EncodingConverter_Convert(PyObject *, PyObject *args, PyObject *kwargs) {
12747 PyObject *resultobj;
12748 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12749 wxString *arg2 = 0 ;
12750 wxString result;
12751 bool temp2 = false ;
12752 PyObject * obj0 = 0 ;
12753 PyObject * obj1 = 0 ;
12754 char *kwnames[] = {
12755 (char *) "self",(char *) "input", NULL
12756 };
12757
12758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_Convert",kwnames,&obj0,&obj1)) goto fail;
12759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12760 if (SWIG_arg_fail(1)) SWIG_fail;
12761 {
12762 arg2 = wxString_in_helper(obj1);
12763 if (arg2 == NULL) SWIG_fail;
12764 temp2 = true;
12765 }
12766 {
12767 PyThreadState* __tstate = wxPyBeginAllowThreads();
12768 result = (arg1)->Convert((wxString const &)*arg2);
12769
12770 wxPyEndAllowThreads(__tstate);
12771 if (PyErr_Occurred()) SWIG_fail;
12772 }
12773 {
12774 #if wxUSE_UNICODE
12775 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12776 #else
12777 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12778 #endif
12779 }
12780 {
12781 if (temp2)
12782 delete arg2;
12783 }
12784 return resultobj;
12785 fail:
12786 {
12787 if (temp2)
12788 delete arg2;
12789 }
12790 return NULL;
12791 }
12792
12793
12794 static PyObject *_wrap_EncodingConverter_GetPlatformEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12795 PyObject *resultobj;
12796 wxFontEncoding arg1 ;
12797 int arg2 = (int) wxPLATFORM_CURRENT ;
12798 wxFontEncodingArray result;
12799 PyObject * obj0 = 0 ;
12800 PyObject * obj1 = 0 ;
12801 char *kwnames[] = {
12802 (char *) "enc",(char *) "platform", NULL
12803 };
12804
12805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EncodingConverter_GetPlatformEquivalents",kwnames,&obj0,&obj1)) goto fail;
12806 {
12807 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12808 if (SWIG_arg_fail(1)) SWIG_fail;
12809 }
12810 if (obj1) {
12811 {
12812 arg2 = (int)(SWIG_As_int(obj1));
12813 if (SWIG_arg_fail(2)) SWIG_fail;
12814 }
12815 }
12816 {
12817 PyThreadState* __tstate = wxPyBeginAllowThreads();
12818 result = wxEncodingConverter::GetPlatformEquivalents((wxFontEncoding )arg1,arg2);
12819
12820 wxPyEndAllowThreads(__tstate);
12821 if (PyErr_Occurred()) SWIG_fail;
12822 }
12823 {
12824 resultobj = PyList_New(0);
12825 for (size_t i=0; i < (&result)->GetCount(); i++) {
12826 PyObject* number = PyInt_FromLong((&result)->Item(i));
12827 PyList_Append(resultobj, number);
12828 Py_DECREF(number);
12829 }
12830 }
12831 return resultobj;
12832 fail:
12833 return NULL;
12834 }
12835
12836
12837 static PyObject *_wrap_EncodingConverter_GetAllEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12838 PyObject *resultobj;
12839 wxFontEncoding arg1 ;
12840 wxFontEncodingArray result;
12841 PyObject * obj0 = 0 ;
12842 char *kwnames[] = {
12843 (char *) "enc", NULL
12844 };
12845
12846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EncodingConverter_GetAllEquivalents",kwnames,&obj0)) goto fail;
12847 {
12848 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12849 if (SWIG_arg_fail(1)) SWIG_fail;
12850 }
12851 {
12852 PyThreadState* __tstate = wxPyBeginAllowThreads();
12853 result = wxEncodingConverter::GetAllEquivalents((wxFontEncoding )arg1);
12854
12855 wxPyEndAllowThreads(__tstate);
12856 if (PyErr_Occurred()) SWIG_fail;
12857 }
12858 {
12859 resultobj = PyList_New(0);
12860 for (size_t i=0; i < (&result)->GetCount(); i++) {
12861 PyObject* number = PyInt_FromLong((&result)->Item(i));
12862 PyList_Append(resultobj, number);
12863 Py_DECREF(number);
12864 }
12865 }
12866 return resultobj;
12867 fail:
12868 return NULL;
12869 }
12870
12871
12872 static PyObject *_wrap_EncodingConverter_CanConvert(PyObject *, PyObject *args, PyObject *kwargs) {
12873 PyObject *resultobj;
12874 wxFontEncoding arg1 ;
12875 wxFontEncoding arg2 ;
12876 bool result;
12877 PyObject * obj0 = 0 ;
12878 PyObject * obj1 = 0 ;
12879 char *kwnames[] = {
12880 (char *) "encIn",(char *) "encOut", NULL
12881 };
12882
12883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_CanConvert",kwnames,&obj0,&obj1)) goto fail;
12884 {
12885 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12886 if (SWIG_arg_fail(1)) SWIG_fail;
12887 }
12888 {
12889 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12890 if (SWIG_arg_fail(2)) SWIG_fail;
12891 }
12892 {
12893 PyThreadState* __tstate = wxPyBeginAllowThreads();
12894 result = (bool)wxEncodingConverter::CanConvert((wxFontEncoding )arg1,(wxFontEncoding )arg2);
12895
12896 wxPyEndAllowThreads(__tstate);
12897 if (PyErr_Occurred()) SWIG_fail;
12898 }
12899 {
12900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12901 }
12902 return resultobj;
12903 fail:
12904 return NULL;
12905 }
12906
12907
12908 static PyObject * EncodingConverter_swigregister(PyObject *, PyObject *args) {
12909 PyObject *obj;
12910 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12911 SWIG_TypeClientData(SWIGTYPE_p_wxEncodingConverter, obj);
12912 Py_INCREF(obj);
12913 return Py_BuildValue((char *)"");
12914 }
12915 static PyObject *_wrap_delete_DC(PyObject *, PyObject *args, PyObject *kwargs) {
12916 PyObject *resultobj;
12917 wxDC *arg1 = (wxDC *) 0 ;
12918 PyObject * obj0 = 0 ;
12919 char *kwnames[] = {
12920 (char *) "self", NULL
12921 };
12922
12923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DC",kwnames,&obj0)) goto fail;
12924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12925 if (SWIG_arg_fail(1)) SWIG_fail;
12926 {
12927 PyThreadState* __tstate = wxPyBeginAllowThreads();
12928 delete arg1;
12929
12930 wxPyEndAllowThreads(__tstate);
12931 if (PyErr_Occurred()) SWIG_fail;
12932 }
12933 Py_INCREF(Py_None); resultobj = Py_None;
12934 return resultobj;
12935 fail:
12936 return NULL;
12937 }
12938
12939
12940 static PyObject *_wrap_DC_BeginDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12941 PyObject *resultobj;
12942 wxDC *arg1 = (wxDC *) 0 ;
12943 PyObject * obj0 = 0 ;
12944 char *kwnames[] = {
12945 (char *) "self", NULL
12946 };
12947
12948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_BeginDrawing",kwnames,&obj0)) goto fail;
12949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12950 if (SWIG_arg_fail(1)) SWIG_fail;
12951 {
12952 PyThreadState* __tstate = wxPyBeginAllowThreads();
12953 (arg1)->BeginDrawing();
12954
12955 wxPyEndAllowThreads(__tstate);
12956 if (PyErr_Occurred()) SWIG_fail;
12957 }
12958 Py_INCREF(Py_None); resultobj = Py_None;
12959 return resultobj;
12960 fail:
12961 return NULL;
12962 }
12963
12964
12965 static PyObject *_wrap_DC_EndDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12966 PyObject *resultobj;
12967 wxDC *arg1 = (wxDC *) 0 ;
12968 PyObject * obj0 = 0 ;
12969 char *kwnames[] = {
12970 (char *) "self", NULL
12971 };
12972
12973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDrawing",kwnames,&obj0)) goto fail;
12974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12975 if (SWIG_arg_fail(1)) SWIG_fail;
12976 {
12977 PyThreadState* __tstate = wxPyBeginAllowThreads();
12978 (arg1)->EndDrawing();
12979
12980 wxPyEndAllowThreads(__tstate);
12981 if (PyErr_Occurred()) SWIG_fail;
12982 }
12983 Py_INCREF(Py_None); resultobj = Py_None;
12984 return resultobj;
12985 fail:
12986 return NULL;
12987 }
12988
12989
12990 static PyObject *_wrap_DC_FloodFill(PyObject *, PyObject *args, PyObject *kwargs) {
12991 PyObject *resultobj;
12992 wxDC *arg1 = (wxDC *) 0 ;
12993 int arg2 ;
12994 int arg3 ;
12995 wxColour *arg4 = 0 ;
12996 int arg5 = (int) wxFLOOD_SURFACE ;
12997 bool result;
12998 wxColour temp4 ;
12999 PyObject * obj0 = 0 ;
13000 PyObject * obj1 = 0 ;
13001 PyObject * obj2 = 0 ;
13002 PyObject * obj3 = 0 ;
13003 PyObject * obj4 = 0 ;
13004 char *kwnames[] = {
13005 (char *) "self",(char *) "x",(char *) "y",(char *) "col",(char *) "style", NULL
13006 };
13007
13008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_FloodFill",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13010 if (SWIG_arg_fail(1)) SWIG_fail;
13011 {
13012 arg2 = (int)(SWIG_As_int(obj1));
13013 if (SWIG_arg_fail(2)) SWIG_fail;
13014 }
13015 {
13016 arg3 = (int)(SWIG_As_int(obj2));
13017 if (SWIG_arg_fail(3)) SWIG_fail;
13018 }
13019 {
13020 arg4 = &temp4;
13021 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
13022 }
13023 if (obj4) {
13024 {
13025 arg5 = (int)(SWIG_As_int(obj4));
13026 if (SWIG_arg_fail(5)) SWIG_fail;
13027 }
13028 }
13029 {
13030 PyThreadState* __tstate = wxPyBeginAllowThreads();
13031 result = (bool)(arg1)->FloodFill(arg2,arg3,(wxColour const &)*arg4,arg5);
13032
13033 wxPyEndAllowThreads(__tstate);
13034 if (PyErr_Occurred()) SWIG_fail;
13035 }
13036 {
13037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13038 }
13039 return resultobj;
13040 fail:
13041 return NULL;
13042 }
13043
13044
13045 static PyObject *_wrap_DC_FloodFillPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13046 PyObject *resultobj;
13047 wxDC *arg1 = (wxDC *) 0 ;
13048 wxPoint *arg2 = 0 ;
13049 wxColour *arg3 = 0 ;
13050 int arg4 = (int) wxFLOOD_SURFACE ;
13051 bool result;
13052 wxPoint temp2 ;
13053 wxColour temp3 ;
13054 PyObject * obj0 = 0 ;
13055 PyObject * obj1 = 0 ;
13056 PyObject * obj2 = 0 ;
13057 PyObject * obj3 = 0 ;
13058 char *kwnames[] = {
13059 (char *) "self",(char *) "pt",(char *) "col",(char *) "style", NULL
13060 };
13061
13062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_FloodFillPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13064 if (SWIG_arg_fail(1)) SWIG_fail;
13065 {
13066 arg2 = &temp2;
13067 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13068 }
13069 {
13070 arg3 = &temp3;
13071 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
13072 }
13073 if (obj3) {
13074 {
13075 arg4 = (int)(SWIG_As_int(obj3));
13076 if (SWIG_arg_fail(4)) SWIG_fail;
13077 }
13078 }
13079 {
13080 PyThreadState* __tstate = wxPyBeginAllowThreads();
13081 result = (bool)(arg1)->FloodFill((wxPoint const &)*arg2,(wxColour const &)*arg3,arg4);
13082
13083 wxPyEndAllowThreads(__tstate);
13084 if (PyErr_Occurred()) SWIG_fail;
13085 }
13086 {
13087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13088 }
13089 return resultobj;
13090 fail:
13091 return NULL;
13092 }
13093
13094
13095 static PyObject *_wrap_DC_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
13096 PyObject *resultobj;
13097 wxDC *arg1 = (wxDC *) 0 ;
13098 int arg2 ;
13099 int arg3 ;
13100 wxColour result;
13101 PyObject * obj0 = 0 ;
13102 PyObject * obj1 = 0 ;
13103 PyObject * obj2 = 0 ;
13104 char *kwnames[] = {
13105 (char *) "self",(char *) "x",(char *) "y", NULL
13106 };
13107
13108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_GetPixel",kwnames,&obj0,&obj1,&obj2)) goto fail;
13109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13110 if (SWIG_arg_fail(1)) SWIG_fail;
13111 {
13112 arg2 = (int)(SWIG_As_int(obj1));
13113 if (SWIG_arg_fail(2)) SWIG_fail;
13114 }
13115 {
13116 arg3 = (int)(SWIG_As_int(obj2));
13117 if (SWIG_arg_fail(3)) SWIG_fail;
13118 }
13119 {
13120 PyThreadState* __tstate = wxPyBeginAllowThreads();
13121 result = wxDC_GetPixel(arg1,arg2,arg3);
13122
13123 wxPyEndAllowThreads(__tstate);
13124 if (PyErr_Occurred()) SWIG_fail;
13125 }
13126 {
13127 wxColour * resultptr;
13128 resultptr = new wxColour((wxColour &)(result));
13129 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13130 }
13131 return resultobj;
13132 fail:
13133 return NULL;
13134 }
13135
13136
13137 static PyObject *_wrap_DC_GetPixelPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13138 PyObject *resultobj;
13139 wxDC *arg1 = (wxDC *) 0 ;
13140 wxPoint *arg2 = 0 ;
13141 wxColour result;
13142 wxPoint temp2 ;
13143 PyObject * obj0 = 0 ;
13144 PyObject * obj1 = 0 ;
13145 char *kwnames[] = {
13146 (char *) "self",(char *) "pt", NULL
13147 };
13148
13149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPixelPoint",kwnames,&obj0,&obj1)) goto fail;
13150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13151 if (SWIG_arg_fail(1)) SWIG_fail;
13152 {
13153 arg2 = &temp2;
13154 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13155 }
13156 {
13157 PyThreadState* __tstate = wxPyBeginAllowThreads();
13158 result = wxDC_GetPixelPoint(arg1,(wxPoint const &)*arg2);
13159
13160 wxPyEndAllowThreads(__tstate);
13161 if (PyErr_Occurred()) SWIG_fail;
13162 }
13163 {
13164 wxColour * resultptr;
13165 resultptr = new wxColour((wxColour &)(result));
13166 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13167 }
13168 return resultobj;
13169 fail:
13170 return NULL;
13171 }
13172
13173
13174 static PyObject *_wrap_DC_DrawLine(PyObject *, PyObject *args, PyObject *kwargs) {
13175 PyObject *resultobj;
13176 wxDC *arg1 = (wxDC *) 0 ;
13177 int arg2 ;
13178 int arg3 ;
13179 int arg4 ;
13180 int arg5 ;
13181 PyObject * obj0 = 0 ;
13182 PyObject * obj1 = 0 ;
13183 PyObject * obj2 = 0 ;
13184 PyObject * obj3 = 0 ;
13185 PyObject * obj4 = 0 ;
13186 char *kwnames[] = {
13187 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2", NULL
13188 };
13189
13190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13192 if (SWIG_arg_fail(1)) SWIG_fail;
13193 {
13194 arg2 = (int)(SWIG_As_int(obj1));
13195 if (SWIG_arg_fail(2)) SWIG_fail;
13196 }
13197 {
13198 arg3 = (int)(SWIG_As_int(obj2));
13199 if (SWIG_arg_fail(3)) SWIG_fail;
13200 }
13201 {
13202 arg4 = (int)(SWIG_As_int(obj3));
13203 if (SWIG_arg_fail(4)) SWIG_fail;
13204 }
13205 {
13206 arg5 = (int)(SWIG_As_int(obj4));
13207 if (SWIG_arg_fail(5)) SWIG_fail;
13208 }
13209 {
13210 PyThreadState* __tstate = wxPyBeginAllowThreads();
13211 (arg1)->DrawLine(arg2,arg3,arg4,arg5);
13212
13213 wxPyEndAllowThreads(__tstate);
13214 if (PyErr_Occurred()) SWIG_fail;
13215 }
13216 Py_INCREF(Py_None); resultobj = Py_None;
13217 return resultobj;
13218 fail:
13219 return NULL;
13220 }
13221
13222
13223 static PyObject *_wrap_DC_DrawLinePoint(PyObject *, PyObject *args, PyObject *kwargs) {
13224 PyObject *resultobj;
13225 wxDC *arg1 = (wxDC *) 0 ;
13226 wxPoint *arg2 = 0 ;
13227 wxPoint *arg3 = 0 ;
13228 wxPoint temp2 ;
13229 wxPoint temp3 ;
13230 PyObject * obj0 = 0 ;
13231 PyObject * obj1 = 0 ;
13232 PyObject * obj2 = 0 ;
13233 char *kwnames[] = {
13234 (char *) "self",(char *) "pt1",(char *) "pt2", NULL
13235 };
13236
13237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawLinePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13239 if (SWIG_arg_fail(1)) SWIG_fail;
13240 {
13241 arg2 = &temp2;
13242 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13243 }
13244 {
13245 arg3 = &temp3;
13246 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13247 }
13248 {
13249 PyThreadState* __tstate = wxPyBeginAllowThreads();
13250 (arg1)->DrawLine((wxPoint const &)*arg2,(wxPoint const &)*arg3);
13251
13252 wxPyEndAllowThreads(__tstate);
13253 if (PyErr_Occurred()) SWIG_fail;
13254 }
13255 Py_INCREF(Py_None); resultobj = Py_None;
13256 return resultobj;
13257 fail:
13258 return NULL;
13259 }
13260
13261
13262 static PyObject *_wrap_DC_CrossHair(PyObject *, PyObject *args, PyObject *kwargs) {
13263 PyObject *resultobj;
13264 wxDC *arg1 = (wxDC *) 0 ;
13265 int arg2 ;
13266 int arg3 ;
13267 PyObject * obj0 = 0 ;
13268 PyObject * obj1 = 0 ;
13269 PyObject * obj2 = 0 ;
13270 char *kwnames[] = {
13271 (char *) "self",(char *) "x",(char *) "y", NULL
13272 };
13273
13274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CrossHair",kwnames,&obj0,&obj1,&obj2)) goto fail;
13275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13276 if (SWIG_arg_fail(1)) SWIG_fail;
13277 {
13278 arg2 = (int)(SWIG_As_int(obj1));
13279 if (SWIG_arg_fail(2)) SWIG_fail;
13280 }
13281 {
13282 arg3 = (int)(SWIG_As_int(obj2));
13283 if (SWIG_arg_fail(3)) SWIG_fail;
13284 }
13285 {
13286 PyThreadState* __tstate = wxPyBeginAllowThreads();
13287 (arg1)->CrossHair(arg2,arg3);
13288
13289 wxPyEndAllowThreads(__tstate);
13290 if (PyErr_Occurred()) SWIG_fail;
13291 }
13292 Py_INCREF(Py_None); resultobj = Py_None;
13293 return resultobj;
13294 fail:
13295 return NULL;
13296 }
13297
13298
13299 static PyObject *_wrap_DC_CrossHairPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13300 PyObject *resultobj;
13301 wxDC *arg1 = (wxDC *) 0 ;
13302 wxPoint *arg2 = 0 ;
13303 wxPoint temp2 ;
13304 PyObject * obj0 = 0 ;
13305 PyObject * obj1 = 0 ;
13306 char *kwnames[] = {
13307 (char *) "self",(char *) "pt", NULL
13308 };
13309
13310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CrossHairPoint",kwnames,&obj0,&obj1)) goto fail;
13311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13312 if (SWIG_arg_fail(1)) SWIG_fail;
13313 {
13314 arg2 = &temp2;
13315 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13316 }
13317 {
13318 PyThreadState* __tstate = wxPyBeginAllowThreads();
13319 (arg1)->CrossHair((wxPoint const &)*arg2);
13320
13321 wxPyEndAllowThreads(__tstate);
13322 if (PyErr_Occurred()) SWIG_fail;
13323 }
13324 Py_INCREF(Py_None); resultobj = Py_None;
13325 return resultobj;
13326 fail:
13327 return NULL;
13328 }
13329
13330
13331 static PyObject *_wrap_DC_DrawArc(PyObject *, PyObject *args, PyObject *kwargs) {
13332 PyObject *resultobj;
13333 wxDC *arg1 = (wxDC *) 0 ;
13334 int arg2 ;
13335 int arg3 ;
13336 int arg4 ;
13337 int arg5 ;
13338 int arg6 ;
13339 int arg7 ;
13340 PyObject * obj0 = 0 ;
13341 PyObject * obj1 = 0 ;
13342 PyObject * obj2 = 0 ;
13343 PyObject * obj3 = 0 ;
13344 PyObject * obj4 = 0 ;
13345 PyObject * obj5 = 0 ;
13346 PyObject * obj6 = 0 ;
13347 char *kwnames[] = {
13348 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2",(char *) "xc",(char *) "yc", NULL
13349 };
13350
13351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13353 if (SWIG_arg_fail(1)) SWIG_fail;
13354 {
13355 arg2 = (int)(SWIG_As_int(obj1));
13356 if (SWIG_arg_fail(2)) SWIG_fail;
13357 }
13358 {
13359 arg3 = (int)(SWIG_As_int(obj2));
13360 if (SWIG_arg_fail(3)) SWIG_fail;
13361 }
13362 {
13363 arg4 = (int)(SWIG_As_int(obj3));
13364 if (SWIG_arg_fail(4)) SWIG_fail;
13365 }
13366 {
13367 arg5 = (int)(SWIG_As_int(obj4));
13368 if (SWIG_arg_fail(5)) SWIG_fail;
13369 }
13370 {
13371 arg6 = (int)(SWIG_As_int(obj5));
13372 if (SWIG_arg_fail(6)) SWIG_fail;
13373 }
13374 {
13375 arg7 = (int)(SWIG_As_int(obj6));
13376 if (SWIG_arg_fail(7)) SWIG_fail;
13377 }
13378 {
13379 PyThreadState* __tstate = wxPyBeginAllowThreads();
13380 (arg1)->DrawArc(arg2,arg3,arg4,arg5,arg6,arg7);
13381
13382 wxPyEndAllowThreads(__tstate);
13383 if (PyErr_Occurred()) SWIG_fail;
13384 }
13385 Py_INCREF(Py_None); resultobj = Py_None;
13386 return resultobj;
13387 fail:
13388 return NULL;
13389 }
13390
13391
13392 static PyObject *_wrap_DC_DrawArcPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13393 PyObject *resultobj;
13394 wxDC *arg1 = (wxDC *) 0 ;
13395 wxPoint *arg2 = 0 ;
13396 wxPoint *arg3 = 0 ;
13397 wxPoint *arg4 = 0 ;
13398 wxPoint temp2 ;
13399 wxPoint temp3 ;
13400 wxPoint temp4 ;
13401 PyObject * obj0 = 0 ;
13402 PyObject * obj1 = 0 ;
13403 PyObject * obj2 = 0 ;
13404 PyObject * obj3 = 0 ;
13405 char *kwnames[] = {
13406 (char *) "self",(char *) "pt1",(char *) "pt2",(char *) "center", NULL
13407 };
13408
13409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawArcPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13411 if (SWIG_arg_fail(1)) SWIG_fail;
13412 {
13413 arg2 = &temp2;
13414 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13415 }
13416 {
13417 arg3 = &temp3;
13418 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13419 }
13420 {
13421 arg4 = &temp4;
13422 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
13423 }
13424 {
13425 PyThreadState* __tstate = wxPyBeginAllowThreads();
13426 (arg1)->DrawArc((wxPoint const &)*arg2,(wxPoint const &)*arg3,(wxPoint const &)*arg4);
13427
13428 wxPyEndAllowThreads(__tstate);
13429 if (PyErr_Occurred()) SWIG_fail;
13430 }
13431 Py_INCREF(Py_None); resultobj = Py_None;
13432 return resultobj;
13433 fail:
13434 return NULL;
13435 }
13436
13437
13438 static PyObject *_wrap_DC_DrawCheckMark(PyObject *, PyObject *args, PyObject *kwargs) {
13439 PyObject *resultobj;
13440 wxDC *arg1 = (wxDC *) 0 ;
13441 int arg2 ;
13442 int arg3 ;
13443 int arg4 ;
13444 int arg5 ;
13445 PyObject * obj0 = 0 ;
13446 PyObject * obj1 = 0 ;
13447 PyObject * obj2 = 0 ;
13448 PyObject * obj3 = 0 ;
13449 PyObject * obj4 = 0 ;
13450 char *kwnames[] = {
13451 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13452 };
13453
13454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawCheckMark",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13456 if (SWIG_arg_fail(1)) SWIG_fail;
13457 {
13458 arg2 = (int)(SWIG_As_int(obj1));
13459 if (SWIG_arg_fail(2)) SWIG_fail;
13460 }
13461 {
13462 arg3 = (int)(SWIG_As_int(obj2));
13463 if (SWIG_arg_fail(3)) SWIG_fail;
13464 }
13465 {
13466 arg4 = (int)(SWIG_As_int(obj3));
13467 if (SWIG_arg_fail(4)) SWIG_fail;
13468 }
13469 {
13470 arg5 = (int)(SWIG_As_int(obj4));
13471 if (SWIG_arg_fail(5)) SWIG_fail;
13472 }
13473 {
13474 PyThreadState* __tstate = wxPyBeginAllowThreads();
13475 (arg1)->DrawCheckMark(arg2,arg3,arg4,arg5);
13476
13477 wxPyEndAllowThreads(__tstate);
13478 if (PyErr_Occurred()) SWIG_fail;
13479 }
13480 Py_INCREF(Py_None); resultobj = Py_None;
13481 return resultobj;
13482 fail:
13483 return NULL;
13484 }
13485
13486
13487 static PyObject *_wrap_DC_DrawCheckMarkRect(PyObject *, PyObject *args, PyObject *kwargs) {
13488 PyObject *resultobj;
13489 wxDC *arg1 = (wxDC *) 0 ;
13490 wxRect *arg2 = 0 ;
13491 wxRect temp2 ;
13492 PyObject * obj0 = 0 ;
13493 PyObject * obj1 = 0 ;
13494 char *kwnames[] = {
13495 (char *) "self",(char *) "rect", NULL
13496 };
13497
13498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawCheckMarkRect",kwnames,&obj0,&obj1)) goto fail;
13499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13500 if (SWIG_arg_fail(1)) SWIG_fail;
13501 {
13502 arg2 = &temp2;
13503 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13504 }
13505 {
13506 PyThreadState* __tstate = wxPyBeginAllowThreads();
13507 (arg1)->DrawCheckMark((wxRect const &)*arg2);
13508
13509 wxPyEndAllowThreads(__tstate);
13510 if (PyErr_Occurred()) SWIG_fail;
13511 }
13512 Py_INCREF(Py_None); resultobj = Py_None;
13513 return resultobj;
13514 fail:
13515 return NULL;
13516 }
13517
13518
13519 static PyObject *_wrap_DC_DrawEllipticArc(PyObject *, PyObject *args, PyObject *kwargs) {
13520 PyObject *resultobj;
13521 wxDC *arg1 = (wxDC *) 0 ;
13522 int arg2 ;
13523 int arg3 ;
13524 int arg4 ;
13525 int arg5 ;
13526 double arg6 ;
13527 double arg7 ;
13528 PyObject * obj0 = 0 ;
13529 PyObject * obj1 = 0 ;
13530 PyObject * obj2 = 0 ;
13531 PyObject * obj3 = 0 ;
13532 PyObject * obj4 = 0 ;
13533 PyObject * obj5 = 0 ;
13534 PyObject * obj6 = 0 ;
13535 char *kwnames[] = {
13536 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h",(char *) "start",(char *) "end", NULL
13537 };
13538
13539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawEllipticArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13541 if (SWIG_arg_fail(1)) SWIG_fail;
13542 {
13543 arg2 = (int)(SWIG_As_int(obj1));
13544 if (SWIG_arg_fail(2)) SWIG_fail;
13545 }
13546 {
13547 arg3 = (int)(SWIG_As_int(obj2));
13548 if (SWIG_arg_fail(3)) SWIG_fail;
13549 }
13550 {
13551 arg4 = (int)(SWIG_As_int(obj3));
13552 if (SWIG_arg_fail(4)) SWIG_fail;
13553 }
13554 {
13555 arg5 = (int)(SWIG_As_int(obj4));
13556 if (SWIG_arg_fail(5)) SWIG_fail;
13557 }
13558 {
13559 arg6 = (double)(SWIG_As_double(obj5));
13560 if (SWIG_arg_fail(6)) SWIG_fail;
13561 }
13562 {
13563 arg7 = (double)(SWIG_As_double(obj6));
13564 if (SWIG_arg_fail(7)) SWIG_fail;
13565 }
13566 {
13567 PyThreadState* __tstate = wxPyBeginAllowThreads();
13568 (arg1)->DrawEllipticArc(arg2,arg3,arg4,arg5,arg6,arg7);
13569
13570 wxPyEndAllowThreads(__tstate);
13571 if (PyErr_Occurred()) SWIG_fail;
13572 }
13573 Py_INCREF(Py_None); resultobj = Py_None;
13574 return resultobj;
13575 fail:
13576 return NULL;
13577 }
13578
13579
13580 static PyObject *_wrap_DC_DrawEllipticArcPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13581 PyObject *resultobj;
13582 wxDC *arg1 = (wxDC *) 0 ;
13583 wxPoint *arg2 = 0 ;
13584 wxSize *arg3 = 0 ;
13585 double arg4 ;
13586 double arg5 ;
13587 wxPoint temp2 ;
13588 wxSize temp3 ;
13589 PyObject * obj0 = 0 ;
13590 PyObject * obj1 = 0 ;
13591 PyObject * obj2 = 0 ;
13592 PyObject * obj3 = 0 ;
13593 PyObject * obj4 = 0 ;
13594 char *kwnames[] = {
13595 (char *) "self",(char *) "pt",(char *) "sz",(char *) "start",(char *) "end", NULL
13596 };
13597
13598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipticArcPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13600 if (SWIG_arg_fail(1)) SWIG_fail;
13601 {
13602 arg2 = &temp2;
13603 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13604 }
13605 {
13606 arg3 = &temp3;
13607 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13608 }
13609 {
13610 arg4 = (double)(SWIG_As_double(obj3));
13611 if (SWIG_arg_fail(4)) SWIG_fail;
13612 }
13613 {
13614 arg5 = (double)(SWIG_As_double(obj4));
13615 if (SWIG_arg_fail(5)) SWIG_fail;
13616 }
13617 {
13618 PyThreadState* __tstate = wxPyBeginAllowThreads();
13619 (arg1)->DrawEllipticArc((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,arg5);
13620
13621 wxPyEndAllowThreads(__tstate);
13622 if (PyErr_Occurred()) SWIG_fail;
13623 }
13624 Py_INCREF(Py_None); resultobj = Py_None;
13625 return resultobj;
13626 fail:
13627 return NULL;
13628 }
13629
13630
13631 static PyObject *_wrap_DC_DrawPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13632 PyObject *resultobj;
13633 wxDC *arg1 = (wxDC *) 0 ;
13634 int arg2 ;
13635 int arg3 ;
13636 PyObject * obj0 = 0 ;
13637 PyObject * obj1 = 0 ;
13638 PyObject * obj2 = 0 ;
13639 char *kwnames[] = {
13640 (char *) "self",(char *) "x",(char *) "y", NULL
13641 };
13642
13643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13645 if (SWIG_arg_fail(1)) SWIG_fail;
13646 {
13647 arg2 = (int)(SWIG_As_int(obj1));
13648 if (SWIG_arg_fail(2)) SWIG_fail;
13649 }
13650 {
13651 arg3 = (int)(SWIG_As_int(obj2));
13652 if (SWIG_arg_fail(3)) SWIG_fail;
13653 }
13654 {
13655 PyThreadState* __tstate = wxPyBeginAllowThreads();
13656 (arg1)->DrawPoint(arg2,arg3);
13657
13658 wxPyEndAllowThreads(__tstate);
13659 if (PyErr_Occurred()) SWIG_fail;
13660 }
13661 Py_INCREF(Py_None); resultobj = Py_None;
13662 return resultobj;
13663 fail:
13664 return NULL;
13665 }
13666
13667
13668 static PyObject *_wrap_DC_DrawPointPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13669 PyObject *resultobj;
13670 wxDC *arg1 = (wxDC *) 0 ;
13671 wxPoint *arg2 = 0 ;
13672 wxPoint temp2 ;
13673 PyObject * obj0 = 0 ;
13674 PyObject * obj1 = 0 ;
13675 char *kwnames[] = {
13676 (char *) "self",(char *) "pt", NULL
13677 };
13678
13679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawPointPoint",kwnames,&obj0,&obj1)) goto fail;
13680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13681 if (SWIG_arg_fail(1)) SWIG_fail;
13682 {
13683 arg2 = &temp2;
13684 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13685 }
13686 {
13687 PyThreadState* __tstate = wxPyBeginAllowThreads();
13688 (arg1)->DrawPoint((wxPoint const &)*arg2);
13689
13690 wxPyEndAllowThreads(__tstate);
13691 if (PyErr_Occurred()) SWIG_fail;
13692 }
13693 Py_INCREF(Py_None); resultobj = Py_None;
13694 return resultobj;
13695 fail:
13696 return NULL;
13697 }
13698
13699
13700 static PyObject *_wrap_DC_DrawRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13701 PyObject *resultobj;
13702 wxDC *arg1 = (wxDC *) 0 ;
13703 int arg2 ;
13704 int arg3 ;
13705 int arg4 ;
13706 int arg5 ;
13707 PyObject * obj0 = 0 ;
13708 PyObject * obj1 = 0 ;
13709 PyObject * obj2 = 0 ;
13710 PyObject * obj3 = 0 ;
13711 PyObject * obj4 = 0 ;
13712 char *kwnames[] = {
13713 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13714 };
13715
13716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13718 if (SWIG_arg_fail(1)) SWIG_fail;
13719 {
13720 arg2 = (int)(SWIG_As_int(obj1));
13721 if (SWIG_arg_fail(2)) SWIG_fail;
13722 }
13723 {
13724 arg3 = (int)(SWIG_As_int(obj2));
13725 if (SWIG_arg_fail(3)) SWIG_fail;
13726 }
13727 {
13728 arg4 = (int)(SWIG_As_int(obj3));
13729 if (SWIG_arg_fail(4)) SWIG_fail;
13730 }
13731 {
13732 arg5 = (int)(SWIG_As_int(obj4));
13733 if (SWIG_arg_fail(5)) SWIG_fail;
13734 }
13735 {
13736 PyThreadState* __tstate = wxPyBeginAllowThreads();
13737 (arg1)->DrawRectangle(arg2,arg3,arg4,arg5);
13738
13739 wxPyEndAllowThreads(__tstate);
13740 if (PyErr_Occurred()) SWIG_fail;
13741 }
13742 Py_INCREF(Py_None); resultobj = Py_None;
13743 return resultobj;
13744 fail:
13745 return NULL;
13746 }
13747
13748
13749 static PyObject *_wrap_DC_DrawRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13750 PyObject *resultobj;
13751 wxDC *arg1 = (wxDC *) 0 ;
13752 wxRect *arg2 = 0 ;
13753 wxRect temp2 ;
13754 PyObject * obj0 = 0 ;
13755 PyObject * obj1 = 0 ;
13756 char *kwnames[] = {
13757 (char *) "self",(char *) "rect", NULL
13758 };
13759
13760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawRectangleRect",kwnames,&obj0,&obj1)) 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 = &temp2;
13765 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13766 }
13767 {
13768 PyThreadState* __tstate = wxPyBeginAllowThreads();
13769 (arg1)->DrawRectangle((wxRect const &)*arg2);
13770
13771 wxPyEndAllowThreads(__tstate);
13772 if (PyErr_Occurred()) SWIG_fail;
13773 }
13774 Py_INCREF(Py_None); resultobj = Py_None;
13775 return resultobj;
13776 fail:
13777 return NULL;
13778 }
13779
13780
13781 static PyObject *_wrap_DC_DrawRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13782 PyObject *resultobj;
13783 wxDC *arg1 = (wxDC *) 0 ;
13784 wxPoint *arg2 = 0 ;
13785 wxSize *arg3 = 0 ;
13786 wxPoint temp2 ;
13787 wxSize temp3 ;
13788 PyObject * obj0 = 0 ;
13789 PyObject * obj1 = 0 ;
13790 PyObject * obj2 = 0 ;
13791 char *kwnames[] = {
13792 (char *) "self",(char *) "pt",(char *) "sz", NULL
13793 };
13794
13795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRectanglePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13797 if (SWIG_arg_fail(1)) SWIG_fail;
13798 {
13799 arg2 = &temp2;
13800 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13801 }
13802 {
13803 arg3 = &temp3;
13804 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13805 }
13806 {
13807 PyThreadState* __tstate = wxPyBeginAllowThreads();
13808 (arg1)->DrawRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3);
13809
13810 wxPyEndAllowThreads(__tstate);
13811 if (PyErr_Occurred()) SWIG_fail;
13812 }
13813 Py_INCREF(Py_None); resultobj = Py_None;
13814 return resultobj;
13815 fail:
13816 return NULL;
13817 }
13818
13819
13820 static PyObject *_wrap_DC_DrawRoundedRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13821 PyObject *resultobj;
13822 wxDC *arg1 = (wxDC *) 0 ;
13823 int arg2 ;
13824 int arg3 ;
13825 int arg4 ;
13826 int arg5 ;
13827 double arg6 ;
13828 PyObject * obj0 = 0 ;
13829 PyObject * obj1 = 0 ;
13830 PyObject * obj2 = 0 ;
13831 PyObject * obj3 = 0 ;
13832 PyObject * obj4 = 0 ;
13833 PyObject * obj5 = 0 ;
13834 char *kwnames[] = {
13835 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "radius", NULL
13836 };
13837
13838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:DC_DrawRoundedRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
13839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13840 if (SWIG_arg_fail(1)) SWIG_fail;
13841 {
13842 arg2 = (int)(SWIG_As_int(obj1));
13843 if (SWIG_arg_fail(2)) SWIG_fail;
13844 }
13845 {
13846 arg3 = (int)(SWIG_As_int(obj2));
13847 if (SWIG_arg_fail(3)) SWIG_fail;
13848 }
13849 {
13850 arg4 = (int)(SWIG_As_int(obj3));
13851 if (SWIG_arg_fail(4)) SWIG_fail;
13852 }
13853 {
13854 arg5 = (int)(SWIG_As_int(obj4));
13855 if (SWIG_arg_fail(5)) SWIG_fail;
13856 }
13857 {
13858 arg6 = (double)(SWIG_As_double(obj5));
13859 if (SWIG_arg_fail(6)) SWIG_fail;
13860 }
13861 {
13862 PyThreadState* __tstate = wxPyBeginAllowThreads();
13863 (arg1)->DrawRoundedRectangle(arg2,arg3,arg4,arg5,arg6);
13864
13865 wxPyEndAllowThreads(__tstate);
13866 if (PyErr_Occurred()) SWIG_fail;
13867 }
13868 Py_INCREF(Py_None); resultobj = Py_None;
13869 return resultobj;
13870 fail:
13871 return NULL;
13872 }
13873
13874
13875 static PyObject *_wrap_DC_DrawRoundedRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13876 PyObject *resultobj;
13877 wxDC *arg1 = (wxDC *) 0 ;
13878 wxRect *arg2 = 0 ;
13879 double arg3 ;
13880 wxRect temp2 ;
13881 PyObject * obj0 = 0 ;
13882 PyObject * obj1 = 0 ;
13883 PyObject * obj2 = 0 ;
13884 char *kwnames[] = {
13885 (char *) "self",(char *) "r",(char *) "radius", NULL
13886 };
13887
13888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRoundedRectangleRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
13889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13890 if (SWIG_arg_fail(1)) SWIG_fail;
13891 {
13892 arg2 = &temp2;
13893 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13894 }
13895 {
13896 arg3 = (double)(SWIG_As_double(obj2));
13897 if (SWIG_arg_fail(3)) SWIG_fail;
13898 }
13899 {
13900 PyThreadState* __tstate = wxPyBeginAllowThreads();
13901 (arg1)->DrawRoundedRectangle((wxRect const &)*arg2,arg3);
13902
13903 wxPyEndAllowThreads(__tstate);
13904 if (PyErr_Occurred()) SWIG_fail;
13905 }
13906 Py_INCREF(Py_None); resultobj = Py_None;
13907 return resultobj;
13908 fail:
13909 return NULL;
13910 }
13911
13912
13913 static PyObject *_wrap_DC_DrawRoundedRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13914 PyObject *resultobj;
13915 wxDC *arg1 = (wxDC *) 0 ;
13916 wxPoint *arg2 = 0 ;
13917 wxSize *arg3 = 0 ;
13918 double arg4 ;
13919 wxPoint temp2 ;
13920 wxSize temp3 ;
13921 PyObject * obj0 = 0 ;
13922 PyObject * obj1 = 0 ;
13923 PyObject * obj2 = 0 ;
13924 PyObject * obj3 = 0 ;
13925 char *kwnames[] = {
13926 (char *) "self",(char *) "pt",(char *) "sz",(char *) "radius", NULL
13927 };
13928
13929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRoundedRectanglePointSize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13931 if (SWIG_arg_fail(1)) SWIG_fail;
13932 {
13933 arg2 = &temp2;
13934 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13935 }
13936 {
13937 arg3 = &temp3;
13938 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13939 }
13940 {
13941 arg4 = (double)(SWIG_As_double(obj3));
13942 if (SWIG_arg_fail(4)) SWIG_fail;
13943 }
13944 {
13945 PyThreadState* __tstate = wxPyBeginAllowThreads();
13946 (arg1)->DrawRoundedRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4);
13947
13948 wxPyEndAllowThreads(__tstate);
13949 if (PyErr_Occurred()) SWIG_fail;
13950 }
13951 Py_INCREF(Py_None); resultobj = Py_None;
13952 return resultobj;
13953 fail:
13954 return NULL;
13955 }
13956
13957
13958 static PyObject *_wrap_DC_DrawCircle(PyObject *, PyObject *args, PyObject *kwargs) {
13959 PyObject *resultobj;
13960 wxDC *arg1 = (wxDC *) 0 ;
13961 int arg2 ;
13962 int arg3 ;
13963 int arg4 ;
13964 PyObject * obj0 = 0 ;
13965 PyObject * obj1 = 0 ;
13966 PyObject * obj2 = 0 ;
13967 PyObject * obj3 = 0 ;
13968 char *kwnames[] = {
13969 (char *) "self",(char *) "x",(char *) "y",(char *) "radius", NULL
13970 };
13971
13972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawCircle",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13974 if (SWIG_arg_fail(1)) SWIG_fail;
13975 {
13976 arg2 = (int)(SWIG_As_int(obj1));
13977 if (SWIG_arg_fail(2)) SWIG_fail;
13978 }
13979 {
13980 arg3 = (int)(SWIG_As_int(obj2));
13981 if (SWIG_arg_fail(3)) SWIG_fail;
13982 }
13983 {
13984 arg4 = (int)(SWIG_As_int(obj3));
13985 if (SWIG_arg_fail(4)) SWIG_fail;
13986 }
13987 {
13988 PyThreadState* __tstate = wxPyBeginAllowThreads();
13989 (arg1)->DrawCircle(arg2,arg3,arg4);
13990
13991 wxPyEndAllowThreads(__tstate);
13992 if (PyErr_Occurred()) SWIG_fail;
13993 }
13994 Py_INCREF(Py_None); resultobj = Py_None;
13995 return resultobj;
13996 fail:
13997 return NULL;
13998 }
13999
14000
14001 static PyObject *_wrap_DC_DrawCirclePoint(PyObject *, PyObject *args, PyObject *kwargs) {
14002 PyObject *resultobj;
14003 wxDC *arg1 = (wxDC *) 0 ;
14004 wxPoint *arg2 = 0 ;
14005 int arg3 ;
14006 wxPoint temp2 ;
14007 PyObject * obj0 = 0 ;
14008 PyObject * obj1 = 0 ;
14009 PyObject * obj2 = 0 ;
14010 char *kwnames[] = {
14011 (char *) "self",(char *) "pt",(char *) "radius", NULL
14012 };
14013
14014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawCirclePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
14015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14016 if (SWIG_arg_fail(1)) SWIG_fail;
14017 {
14018 arg2 = &temp2;
14019 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14020 }
14021 {
14022 arg3 = (int)(SWIG_As_int(obj2));
14023 if (SWIG_arg_fail(3)) SWIG_fail;
14024 }
14025 {
14026 PyThreadState* __tstate = wxPyBeginAllowThreads();
14027 (arg1)->DrawCircle((wxPoint const &)*arg2,arg3);
14028
14029 wxPyEndAllowThreads(__tstate);
14030 if (PyErr_Occurred()) SWIG_fail;
14031 }
14032 Py_INCREF(Py_None); resultobj = Py_None;
14033 return resultobj;
14034 fail:
14035 return NULL;
14036 }
14037
14038
14039 static PyObject *_wrap_DC_DrawEllipse(PyObject *, PyObject *args, PyObject *kwargs) {
14040 PyObject *resultobj;
14041 wxDC *arg1 = (wxDC *) 0 ;
14042 int arg2 ;
14043 int arg3 ;
14044 int arg4 ;
14045 int arg5 ;
14046 PyObject * obj0 = 0 ;
14047 PyObject * obj1 = 0 ;
14048 PyObject * obj2 = 0 ;
14049 PyObject * obj3 = 0 ;
14050 PyObject * obj4 = 0 ;
14051 char *kwnames[] = {
14052 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
14053 };
14054
14055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipse",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14057 if (SWIG_arg_fail(1)) SWIG_fail;
14058 {
14059 arg2 = (int)(SWIG_As_int(obj1));
14060 if (SWIG_arg_fail(2)) SWIG_fail;
14061 }
14062 {
14063 arg3 = (int)(SWIG_As_int(obj2));
14064 if (SWIG_arg_fail(3)) SWIG_fail;
14065 }
14066 {
14067 arg4 = (int)(SWIG_As_int(obj3));
14068 if (SWIG_arg_fail(4)) SWIG_fail;
14069 }
14070 {
14071 arg5 = (int)(SWIG_As_int(obj4));
14072 if (SWIG_arg_fail(5)) SWIG_fail;
14073 }
14074 {
14075 PyThreadState* __tstate = wxPyBeginAllowThreads();
14076 (arg1)->DrawEllipse(arg2,arg3,arg4,arg5);
14077
14078 wxPyEndAllowThreads(__tstate);
14079 if (PyErr_Occurred()) SWIG_fail;
14080 }
14081 Py_INCREF(Py_None); resultobj = Py_None;
14082 return resultobj;
14083 fail:
14084 return NULL;
14085 }
14086
14087
14088 static PyObject *_wrap_DC_DrawEllipseRect(PyObject *, PyObject *args, PyObject *kwargs) {
14089 PyObject *resultobj;
14090 wxDC *arg1 = (wxDC *) 0 ;
14091 wxRect *arg2 = 0 ;
14092 wxRect temp2 ;
14093 PyObject * obj0 = 0 ;
14094 PyObject * obj1 = 0 ;
14095 char *kwnames[] = {
14096 (char *) "self",(char *) "rect", NULL
14097 };
14098
14099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawEllipseRect",kwnames,&obj0,&obj1)) goto fail;
14100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14101 if (SWIG_arg_fail(1)) SWIG_fail;
14102 {
14103 arg2 = &temp2;
14104 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14105 }
14106 {
14107 PyThreadState* __tstate = wxPyBeginAllowThreads();
14108 (arg1)->DrawEllipse((wxRect const &)*arg2);
14109
14110 wxPyEndAllowThreads(__tstate);
14111 if (PyErr_Occurred()) SWIG_fail;
14112 }
14113 Py_INCREF(Py_None); resultobj = Py_None;
14114 return resultobj;
14115 fail:
14116 return NULL;
14117 }
14118
14119
14120 static PyObject *_wrap_DC_DrawEllipsePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14121 PyObject *resultobj;
14122 wxDC *arg1 = (wxDC *) 0 ;
14123 wxPoint *arg2 = 0 ;
14124 wxSize *arg3 = 0 ;
14125 wxPoint temp2 ;
14126 wxSize temp3 ;
14127 PyObject * obj0 = 0 ;
14128 PyObject * obj1 = 0 ;
14129 PyObject * obj2 = 0 ;
14130 char *kwnames[] = {
14131 (char *) "self",(char *) "pt",(char *) "sz", NULL
14132 };
14133
14134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawEllipsePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14136 if (SWIG_arg_fail(1)) SWIG_fail;
14137 {
14138 arg2 = &temp2;
14139 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14140 }
14141 {
14142 arg3 = &temp3;
14143 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14144 }
14145 {
14146 PyThreadState* __tstate = wxPyBeginAllowThreads();
14147 (arg1)->DrawEllipse((wxPoint const &)*arg2,(wxSize const &)*arg3);
14148
14149 wxPyEndAllowThreads(__tstate);
14150 if (PyErr_Occurred()) SWIG_fail;
14151 }
14152 Py_INCREF(Py_None); resultobj = Py_None;
14153 return resultobj;
14154 fail:
14155 return NULL;
14156 }
14157
14158
14159 static PyObject *_wrap_DC_DrawIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14160 PyObject *resultobj;
14161 wxDC *arg1 = (wxDC *) 0 ;
14162 wxIcon *arg2 = 0 ;
14163 int arg3 ;
14164 int arg4 ;
14165 PyObject * obj0 = 0 ;
14166 PyObject * obj1 = 0 ;
14167 PyObject * obj2 = 0 ;
14168 PyObject * obj3 = 0 ;
14169 char *kwnames[] = {
14170 (char *) "self",(char *) "icon",(char *) "x",(char *) "y", NULL
14171 };
14172
14173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14175 if (SWIG_arg_fail(1)) SWIG_fail;
14176 {
14177 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
14178 if (SWIG_arg_fail(2)) SWIG_fail;
14179 if (arg2 == NULL) {
14180 SWIG_null_ref("wxIcon");
14181 }
14182 if (SWIG_arg_fail(2)) SWIG_fail;
14183 }
14184 {
14185 arg3 = (int)(SWIG_As_int(obj2));
14186 if (SWIG_arg_fail(3)) SWIG_fail;
14187 }
14188 {
14189 arg4 = (int)(SWIG_As_int(obj3));
14190 if (SWIG_arg_fail(4)) SWIG_fail;
14191 }
14192 {
14193 PyThreadState* __tstate = wxPyBeginAllowThreads();
14194 (arg1)->DrawIcon((wxIcon const &)*arg2,arg3,arg4);
14195
14196 wxPyEndAllowThreads(__tstate);
14197 if (PyErr_Occurred()) SWIG_fail;
14198 }
14199 Py_INCREF(Py_None); resultobj = Py_None;
14200 return resultobj;
14201 fail:
14202 return NULL;
14203 }
14204
14205
14206 static PyObject *_wrap_DC_DrawIconPoint(PyObject *, PyObject *args, PyObject *kwargs) {
14207 PyObject *resultobj;
14208 wxDC *arg1 = (wxDC *) 0 ;
14209 wxIcon *arg2 = 0 ;
14210 wxPoint *arg3 = 0 ;
14211 wxPoint temp3 ;
14212 PyObject * obj0 = 0 ;
14213 PyObject * obj1 = 0 ;
14214 PyObject * obj2 = 0 ;
14215 char *kwnames[] = {
14216 (char *) "self",(char *) "icon",(char *) "pt", NULL
14217 };
14218
14219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawIconPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
14220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14221 if (SWIG_arg_fail(1)) SWIG_fail;
14222 {
14223 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
14224 if (SWIG_arg_fail(2)) SWIG_fail;
14225 if (arg2 == NULL) {
14226 SWIG_null_ref("wxIcon");
14227 }
14228 if (SWIG_arg_fail(2)) SWIG_fail;
14229 }
14230 {
14231 arg3 = &temp3;
14232 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14233 }
14234 {
14235 PyThreadState* __tstate = wxPyBeginAllowThreads();
14236 (arg1)->DrawIcon((wxIcon const &)*arg2,(wxPoint const &)*arg3);
14237
14238 wxPyEndAllowThreads(__tstate);
14239 if (PyErr_Occurred()) SWIG_fail;
14240 }
14241 Py_INCREF(Py_None); resultobj = Py_None;
14242 return resultobj;
14243 fail:
14244 return NULL;
14245 }
14246
14247
14248 static PyObject *_wrap_DC_DrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14249 PyObject *resultobj;
14250 wxDC *arg1 = (wxDC *) 0 ;
14251 wxBitmap *arg2 = 0 ;
14252 int arg3 ;
14253 int arg4 ;
14254 bool arg5 = (bool) false ;
14255 PyObject * obj0 = 0 ;
14256 PyObject * obj1 = 0 ;
14257 PyObject * obj2 = 0 ;
14258 PyObject * obj3 = 0 ;
14259 PyObject * obj4 = 0 ;
14260 char *kwnames[] = {
14261 (char *) "self",(char *) "bmp",(char *) "x",(char *) "y",(char *) "useMask", NULL
14262 };
14263
14264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_DrawBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14266 if (SWIG_arg_fail(1)) SWIG_fail;
14267 {
14268 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
14269 if (SWIG_arg_fail(2)) SWIG_fail;
14270 if (arg2 == NULL) {
14271 SWIG_null_ref("wxBitmap");
14272 }
14273 if (SWIG_arg_fail(2)) SWIG_fail;
14274 }
14275 {
14276 arg3 = (int)(SWIG_As_int(obj2));
14277 if (SWIG_arg_fail(3)) SWIG_fail;
14278 }
14279 {
14280 arg4 = (int)(SWIG_As_int(obj3));
14281 if (SWIG_arg_fail(4)) SWIG_fail;
14282 }
14283 if (obj4) {
14284 {
14285 arg5 = (bool)(SWIG_As_bool(obj4));
14286 if (SWIG_arg_fail(5)) SWIG_fail;
14287 }
14288 }
14289 {
14290 PyThreadState* __tstate = wxPyBeginAllowThreads();
14291 (arg1)->DrawBitmap((wxBitmap const &)*arg2,arg3,arg4,arg5);
14292
14293 wxPyEndAllowThreads(__tstate);
14294 if (PyErr_Occurred()) SWIG_fail;
14295 }
14296 Py_INCREF(Py_None); resultobj = Py_None;
14297 return resultobj;
14298 fail:
14299 return NULL;
14300 }
14301
14302
14303 static PyObject *_wrap_DC_DrawBitmapPoint(PyObject *, PyObject *args, PyObject *kwargs) {
14304 PyObject *resultobj;
14305 wxDC *arg1 = (wxDC *) 0 ;
14306 wxBitmap *arg2 = 0 ;
14307 wxPoint *arg3 = 0 ;
14308 bool arg4 = (bool) false ;
14309 wxPoint temp3 ;
14310 PyObject * obj0 = 0 ;
14311 PyObject * obj1 = 0 ;
14312 PyObject * obj2 = 0 ;
14313 PyObject * obj3 = 0 ;
14314 char *kwnames[] = {
14315 (char *) "self",(char *) "bmp",(char *) "pt",(char *) "useMask", NULL
14316 };
14317
14318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_DrawBitmapPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14320 if (SWIG_arg_fail(1)) SWIG_fail;
14321 {
14322 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
14323 if (SWIG_arg_fail(2)) SWIG_fail;
14324 if (arg2 == NULL) {
14325 SWIG_null_ref("wxBitmap");
14326 }
14327 if (SWIG_arg_fail(2)) SWIG_fail;
14328 }
14329 {
14330 arg3 = &temp3;
14331 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14332 }
14333 if (obj3) {
14334 {
14335 arg4 = (bool)(SWIG_As_bool(obj3));
14336 if (SWIG_arg_fail(4)) SWIG_fail;
14337 }
14338 }
14339 {
14340 PyThreadState* __tstate = wxPyBeginAllowThreads();
14341 (arg1)->DrawBitmap((wxBitmap const &)*arg2,(wxPoint const &)*arg3,arg4);
14342
14343 wxPyEndAllowThreads(__tstate);
14344 if (PyErr_Occurred()) SWIG_fail;
14345 }
14346 Py_INCREF(Py_None); resultobj = Py_None;
14347 return resultobj;
14348 fail:
14349 return NULL;
14350 }
14351
14352
14353 static PyObject *_wrap_DC_DrawText(PyObject *, PyObject *args, PyObject *kwargs) {
14354 PyObject *resultobj;
14355 wxDC *arg1 = (wxDC *) 0 ;
14356 wxString *arg2 = 0 ;
14357 int arg3 ;
14358 int arg4 ;
14359 bool temp2 = false ;
14360 PyObject * obj0 = 0 ;
14361 PyObject * obj1 = 0 ;
14362 PyObject * obj2 = 0 ;
14363 PyObject * obj3 = 0 ;
14364 char *kwnames[] = {
14365 (char *) "self",(char *) "text",(char *) "x",(char *) "y", NULL
14366 };
14367
14368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawText",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14370 if (SWIG_arg_fail(1)) SWIG_fail;
14371 {
14372 arg2 = wxString_in_helper(obj1);
14373 if (arg2 == NULL) SWIG_fail;
14374 temp2 = true;
14375 }
14376 {
14377 arg3 = (int)(SWIG_As_int(obj2));
14378 if (SWIG_arg_fail(3)) SWIG_fail;
14379 }
14380 {
14381 arg4 = (int)(SWIG_As_int(obj3));
14382 if (SWIG_arg_fail(4)) SWIG_fail;
14383 }
14384 {
14385 PyThreadState* __tstate = wxPyBeginAllowThreads();
14386 (arg1)->DrawText((wxString const &)*arg2,arg3,arg4);
14387
14388 wxPyEndAllowThreads(__tstate);
14389 if (PyErr_Occurred()) SWIG_fail;
14390 }
14391 Py_INCREF(Py_None); resultobj = Py_None;
14392 {
14393 if (temp2)
14394 delete arg2;
14395 }
14396 return resultobj;
14397 fail:
14398 {
14399 if (temp2)
14400 delete arg2;
14401 }
14402 return NULL;
14403 }
14404
14405
14406 static PyObject *_wrap_DC_DrawTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
14407 PyObject *resultobj;
14408 wxDC *arg1 = (wxDC *) 0 ;
14409 wxString *arg2 = 0 ;
14410 wxPoint *arg3 = 0 ;
14411 bool temp2 = false ;
14412 wxPoint temp3 ;
14413 PyObject * obj0 = 0 ;
14414 PyObject * obj1 = 0 ;
14415 PyObject * obj2 = 0 ;
14416 char *kwnames[] = {
14417 (char *) "self",(char *) "text",(char *) "pt", NULL
14418 };
14419
14420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawTextPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
14421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14422 if (SWIG_arg_fail(1)) SWIG_fail;
14423 {
14424 arg2 = wxString_in_helper(obj1);
14425 if (arg2 == NULL) SWIG_fail;
14426 temp2 = true;
14427 }
14428 {
14429 arg3 = &temp3;
14430 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14431 }
14432 {
14433 PyThreadState* __tstate = wxPyBeginAllowThreads();
14434 (arg1)->DrawText((wxString const &)*arg2,(wxPoint const &)*arg3);
14435
14436 wxPyEndAllowThreads(__tstate);
14437 if (PyErr_Occurred()) SWIG_fail;
14438 }
14439 Py_INCREF(Py_None); resultobj = Py_None;
14440 {
14441 if (temp2)
14442 delete arg2;
14443 }
14444 return resultobj;
14445 fail:
14446 {
14447 if (temp2)
14448 delete arg2;
14449 }
14450 return NULL;
14451 }
14452
14453
14454 static PyObject *_wrap_DC_DrawRotatedText(PyObject *, PyObject *args, PyObject *kwargs) {
14455 PyObject *resultobj;
14456 wxDC *arg1 = (wxDC *) 0 ;
14457 wxString *arg2 = 0 ;
14458 int arg3 ;
14459 int arg4 ;
14460 double arg5 ;
14461 bool temp2 = false ;
14462 PyObject * obj0 = 0 ;
14463 PyObject * obj1 = 0 ;
14464 PyObject * obj2 = 0 ;
14465 PyObject * obj3 = 0 ;
14466 PyObject * obj4 = 0 ;
14467 char *kwnames[] = {
14468 (char *) "self",(char *) "text",(char *) "x",(char *) "y",(char *) "angle", NULL
14469 };
14470
14471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRotatedText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14473 if (SWIG_arg_fail(1)) SWIG_fail;
14474 {
14475 arg2 = wxString_in_helper(obj1);
14476 if (arg2 == NULL) SWIG_fail;
14477 temp2 = true;
14478 }
14479 {
14480 arg3 = (int)(SWIG_As_int(obj2));
14481 if (SWIG_arg_fail(3)) SWIG_fail;
14482 }
14483 {
14484 arg4 = (int)(SWIG_As_int(obj3));
14485 if (SWIG_arg_fail(4)) SWIG_fail;
14486 }
14487 {
14488 arg5 = (double)(SWIG_As_double(obj4));
14489 if (SWIG_arg_fail(5)) SWIG_fail;
14490 }
14491 {
14492 PyThreadState* __tstate = wxPyBeginAllowThreads();
14493 (arg1)->DrawRotatedText((wxString const &)*arg2,arg3,arg4,arg5);
14494
14495 wxPyEndAllowThreads(__tstate);
14496 if (PyErr_Occurred()) SWIG_fail;
14497 }
14498 Py_INCREF(Py_None); resultobj = Py_None;
14499 {
14500 if (temp2)
14501 delete arg2;
14502 }
14503 return resultobj;
14504 fail:
14505 {
14506 if (temp2)
14507 delete arg2;
14508 }
14509 return NULL;
14510 }
14511
14512
14513 static PyObject *_wrap_DC_DrawRotatedTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
14514 PyObject *resultobj;
14515 wxDC *arg1 = (wxDC *) 0 ;
14516 wxString *arg2 = 0 ;
14517 wxPoint *arg3 = 0 ;
14518 double arg4 ;
14519 bool temp2 = false ;
14520 wxPoint temp3 ;
14521 PyObject * obj0 = 0 ;
14522 PyObject * obj1 = 0 ;
14523 PyObject * obj2 = 0 ;
14524 PyObject * obj3 = 0 ;
14525 char *kwnames[] = {
14526 (char *) "self",(char *) "text",(char *) "pt",(char *) "angle", NULL
14527 };
14528
14529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRotatedTextPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14531 if (SWIG_arg_fail(1)) SWIG_fail;
14532 {
14533 arg2 = wxString_in_helper(obj1);
14534 if (arg2 == NULL) SWIG_fail;
14535 temp2 = true;
14536 }
14537 {
14538 arg3 = &temp3;
14539 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14540 }
14541 {
14542 arg4 = (double)(SWIG_As_double(obj3));
14543 if (SWIG_arg_fail(4)) SWIG_fail;
14544 }
14545 {
14546 PyThreadState* __tstate = wxPyBeginAllowThreads();
14547 (arg1)->DrawRotatedText((wxString const &)*arg2,(wxPoint const &)*arg3,arg4);
14548
14549 wxPyEndAllowThreads(__tstate);
14550 if (PyErr_Occurred()) SWIG_fail;
14551 }
14552 Py_INCREF(Py_None); resultobj = Py_None;
14553 {
14554 if (temp2)
14555 delete arg2;
14556 }
14557 return resultobj;
14558 fail:
14559 {
14560 if (temp2)
14561 delete arg2;
14562 }
14563 return NULL;
14564 }
14565
14566
14567 static PyObject *_wrap_DC_Blit(PyObject *, PyObject *args, PyObject *kwargs) {
14568 PyObject *resultobj;
14569 wxDC *arg1 = (wxDC *) 0 ;
14570 int arg2 ;
14571 int arg3 ;
14572 int arg4 ;
14573 int arg5 ;
14574 wxDC *arg6 = (wxDC *) 0 ;
14575 int arg7 ;
14576 int arg8 ;
14577 int arg9 = (int) wxCOPY ;
14578 bool arg10 = (bool) false ;
14579 int arg11 = (int) -1 ;
14580 int arg12 = (int) -1 ;
14581 bool result;
14582 PyObject * obj0 = 0 ;
14583 PyObject * obj1 = 0 ;
14584 PyObject * obj2 = 0 ;
14585 PyObject * obj3 = 0 ;
14586 PyObject * obj4 = 0 ;
14587 PyObject * obj5 = 0 ;
14588 PyObject * obj6 = 0 ;
14589 PyObject * obj7 = 0 ;
14590 PyObject * obj8 = 0 ;
14591 PyObject * obj9 = 0 ;
14592 PyObject * obj10 = 0 ;
14593 PyObject * obj11 = 0 ;
14594 char *kwnames[] = {
14595 (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
14596 };
14597
14598 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;
14599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14600 if (SWIG_arg_fail(1)) SWIG_fail;
14601 {
14602 arg2 = (int)(SWIG_As_int(obj1));
14603 if (SWIG_arg_fail(2)) SWIG_fail;
14604 }
14605 {
14606 arg3 = (int)(SWIG_As_int(obj2));
14607 if (SWIG_arg_fail(3)) SWIG_fail;
14608 }
14609 {
14610 arg4 = (int)(SWIG_As_int(obj3));
14611 if (SWIG_arg_fail(4)) SWIG_fail;
14612 }
14613 {
14614 arg5 = (int)(SWIG_As_int(obj4));
14615 if (SWIG_arg_fail(5)) SWIG_fail;
14616 }
14617 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14618 if (SWIG_arg_fail(6)) SWIG_fail;
14619 {
14620 arg7 = (int)(SWIG_As_int(obj6));
14621 if (SWIG_arg_fail(7)) SWIG_fail;
14622 }
14623 {
14624 arg8 = (int)(SWIG_As_int(obj7));
14625 if (SWIG_arg_fail(8)) SWIG_fail;
14626 }
14627 if (obj8) {
14628 {
14629 arg9 = (int)(SWIG_As_int(obj8));
14630 if (SWIG_arg_fail(9)) SWIG_fail;
14631 }
14632 }
14633 if (obj9) {
14634 {
14635 arg10 = (bool)(SWIG_As_bool(obj9));
14636 if (SWIG_arg_fail(10)) SWIG_fail;
14637 }
14638 }
14639 if (obj10) {
14640 {
14641 arg11 = (int)(SWIG_As_int(obj10));
14642 if (SWIG_arg_fail(11)) SWIG_fail;
14643 }
14644 }
14645 if (obj11) {
14646 {
14647 arg12 = (int)(SWIG_As_int(obj11));
14648 if (SWIG_arg_fail(12)) SWIG_fail;
14649 }
14650 }
14651 {
14652 PyThreadState* __tstate = wxPyBeginAllowThreads();
14653 result = (bool)(arg1)->Blit(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
14654
14655 wxPyEndAllowThreads(__tstate);
14656 if (PyErr_Occurred()) SWIG_fail;
14657 }
14658 {
14659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14660 }
14661 return resultobj;
14662 fail:
14663 return NULL;
14664 }
14665
14666
14667 static PyObject *_wrap_DC_BlitPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14668 PyObject *resultobj;
14669 wxDC *arg1 = (wxDC *) 0 ;
14670 wxPoint *arg2 = 0 ;
14671 wxSize *arg3 = 0 ;
14672 wxDC *arg4 = (wxDC *) 0 ;
14673 wxPoint *arg5 = 0 ;
14674 int arg6 = (int) wxCOPY ;
14675 bool arg7 = (bool) false ;
14676 wxPoint const &arg8_defvalue = wxDefaultPosition ;
14677 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
14678 bool result;
14679 wxPoint temp2 ;
14680 wxSize temp3 ;
14681 wxPoint temp5 ;
14682 wxPoint temp8 ;
14683 PyObject * obj0 = 0 ;
14684 PyObject * obj1 = 0 ;
14685 PyObject * obj2 = 0 ;
14686 PyObject * obj3 = 0 ;
14687 PyObject * obj4 = 0 ;
14688 PyObject * obj5 = 0 ;
14689 PyObject * obj6 = 0 ;
14690 PyObject * obj7 = 0 ;
14691 char *kwnames[] = {
14692 (char *) "self",(char *) "destPt",(char *) "sz",(char *) "source",(char *) "srcPt",(char *) "rop",(char *) "useMask",(char *) "srcPtMask", NULL
14693 };
14694
14695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:DC_BlitPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
14696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14697 if (SWIG_arg_fail(1)) SWIG_fail;
14698 {
14699 arg2 = &temp2;
14700 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14701 }
14702 {
14703 arg3 = &temp3;
14704 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14705 }
14706 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14707 if (SWIG_arg_fail(4)) SWIG_fail;
14708 {
14709 arg5 = &temp5;
14710 if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
14711 }
14712 if (obj5) {
14713 {
14714 arg6 = (int)(SWIG_As_int(obj5));
14715 if (SWIG_arg_fail(6)) SWIG_fail;
14716 }
14717 }
14718 if (obj6) {
14719 {
14720 arg7 = (bool)(SWIG_As_bool(obj6));
14721 if (SWIG_arg_fail(7)) SWIG_fail;
14722 }
14723 }
14724 if (obj7) {
14725 {
14726 arg8 = &temp8;
14727 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
14728 }
14729 }
14730 {
14731 PyThreadState* __tstate = wxPyBeginAllowThreads();
14732 result = (bool)(arg1)->Blit((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,(wxPoint const &)*arg5,arg6,arg7,(wxPoint const &)*arg8);
14733
14734 wxPyEndAllowThreads(__tstate);
14735 if (PyErr_Occurred()) SWIG_fail;
14736 }
14737 {
14738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14739 }
14740 return resultobj;
14741 fail:
14742 return NULL;
14743 }
14744
14745
14746 static PyObject *_wrap_DC_SetClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14747 PyObject *resultobj;
14748 wxDC *arg1 = (wxDC *) 0 ;
14749 int arg2 ;
14750 int arg3 ;
14751 int arg4 ;
14752 int arg5 ;
14753 PyObject * obj0 = 0 ;
14754 PyObject * obj1 = 0 ;
14755 PyObject * obj2 = 0 ;
14756 PyObject * obj3 = 0 ;
14757 PyObject * obj4 = 0 ;
14758 char *kwnames[] = {
14759 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
14760 };
14761
14762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_SetClippingRegion",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14764 if (SWIG_arg_fail(1)) SWIG_fail;
14765 {
14766 arg2 = (int)(SWIG_As_int(obj1));
14767 if (SWIG_arg_fail(2)) SWIG_fail;
14768 }
14769 {
14770 arg3 = (int)(SWIG_As_int(obj2));
14771 if (SWIG_arg_fail(3)) SWIG_fail;
14772 }
14773 {
14774 arg4 = (int)(SWIG_As_int(obj3));
14775 if (SWIG_arg_fail(4)) SWIG_fail;
14776 }
14777 {
14778 arg5 = (int)(SWIG_As_int(obj4));
14779 if (SWIG_arg_fail(5)) SWIG_fail;
14780 }
14781 {
14782 PyThreadState* __tstate = wxPyBeginAllowThreads();
14783 (arg1)->SetClippingRegion(arg2,arg3,arg4,arg5);
14784
14785 wxPyEndAllowThreads(__tstate);
14786 if (PyErr_Occurred()) SWIG_fail;
14787 }
14788 Py_INCREF(Py_None); resultobj = Py_None;
14789 return resultobj;
14790 fail:
14791 return NULL;
14792 }
14793
14794
14795 static PyObject *_wrap_DC_SetClippingRegionPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14796 PyObject *resultobj;
14797 wxDC *arg1 = (wxDC *) 0 ;
14798 wxPoint *arg2 = 0 ;
14799 wxSize *arg3 = 0 ;
14800 wxPoint temp2 ;
14801 wxSize temp3 ;
14802 PyObject * obj0 = 0 ;
14803 PyObject * obj1 = 0 ;
14804 PyObject * obj2 = 0 ;
14805 char *kwnames[] = {
14806 (char *) "self",(char *) "pt",(char *) "sz", NULL
14807 };
14808
14809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetClippingRegionPointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14811 if (SWIG_arg_fail(1)) SWIG_fail;
14812 {
14813 arg2 = &temp2;
14814 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14815 }
14816 {
14817 arg3 = &temp3;
14818 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14819 }
14820 {
14821 PyThreadState* __tstate = wxPyBeginAllowThreads();
14822 (arg1)->SetClippingRegion((wxPoint const &)*arg2,(wxSize const &)*arg3);
14823
14824 wxPyEndAllowThreads(__tstate);
14825 if (PyErr_Occurred()) SWIG_fail;
14826 }
14827 Py_INCREF(Py_None); resultobj = Py_None;
14828 return resultobj;
14829 fail:
14830 return NULL;
14831 }
14832
14833
14834 static PyObject *_wrap_DC_SetClippingRegionAsRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14835 PyObject *resultobj;
14836 wxDC *arg1 = (wxDC *) 0 ;
14837 wxRegion *arg2 = 0 ;
14838 PyObject * obj0 = 0 ;
14839 PyObject * obj1 = 0 ;
14840 char *kwnames[] = {
14841 (char *) "self",(char *) "region", NULL
14842 };
14843
14844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRegionAsRegion",kwnames,&obj0,&obj1)) goto fail;
14845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14846 if (SWIG_arg_fail(1)) SWIG_fail;
14847 {
14848 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
14849 if (SWIG_arg_fail(2)) SWIG_fail;
14850 if (arg2 == NULL) {
14851 SWIG_null_ref("wxRegion");
14852 }
14853 if (SWIG_arg_fail(2)) SWIG_fail;
14854 }
14855 {
14856 PyThreadState* __tstate = wxPyBeginAllowThreads();
14857 (arg1)->SetClippingRegion((wxRegion const &)*arg2);
14858
14859 wxPyEndAllowThreads(__tstate);
14860 if (PyErr_Occurred()) SWIG_fail;
14861 }
14862 Py_INCREF(Py_None); resultobj = Py_None;
14863 return resultobj;
14864 fail:
14865 return NULL;
14866 }
14867
14868
14869 static PyObject *_wrap_DC_SetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
14870 PyObject *resultobj;
14871 wxDC *arg1 = (wxDC *) 0 ;
14872 wxRect *arg2 = 0 ;
14873 wxRect temp2 ;
14874 PyObject * obj0 = 0 ;
14875 PyObject * obj1 = 0 ;
14876 char *kwnames[] = {
14877 (char *) "self",(char *) "rect", NULL
14878 };
14879
14880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRect",kwnames,&obj0,&obj1)) goto fail;
14881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14882 if (SWIG_arg_fail(1)) SWIG_fail;
14883 {
14884 arg2 = &temp2;
14885 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14886 }
14887 {
14888 PyThreadState* __tstate = wxPyBeginAllowThreads();
14889 (arg1)->SetClippingRegion((wxRect const &)*arg2);
14890
14891 wxPyEndAllowThreads(__tstate);
14892 if (PyErr_Occurred()) SWIG_fail;
14893 }
14894 Py_INCREF(Py_None); resultobj = Py_None;
14895 return resultobj;
14896 fail:
14897 return NULL;
14898 }
14899
14900
14901 static PyObject *_wrap_DC_DrawLines(PyObject *, PyObject *args, PyObject *kwargs) {
14902 PyObject *resultobj;
14903 wxDC *arg1 = (wxDC *) 0 ;
14904 int arg2 ;
14905 wxPoint *arg3 = (wxPoint *) 0 ;
14906 int arg4 = (int) 0 ;
14907 int arg5 = (int) 0 ;
14908 PyObject * obj0 = 0 ;
14909 PyObject * obj1 = 0 ;
14910 PyObject * obj2 = 0 ;
14911 PyObject * obj3 = 0 ;
14912 char *kwnames[] = {
14913 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset", NULL
14914 };
14915
14916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DC_DrawLines",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14918 if (SWIG_arg_fail(1)) SWIG_fail;
14919 {
14920 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14921 if (arg3 == NULL) SWIG_fail;
14922 }
14923 if (obj2) {
14924 {
14925 arg4 = (int)(SWIG_As_int(obj2));
14926 if (SWIG_arg_fail(4)) SWIG_fail;
14927 }
14928 }
14929 if (obj3) {
14930 {
14931 arg5 = (int)(SWIG_As_int(obj3));
14932 if (SWIG_arg_fail(5)) SWIG_fail;
14933 }
14934 }
14935 {
14936 PyThreadState* __tstate = wxPyBeginAllowThreads();
14937 (arg1)->DrawLines(arg2,arg3,arg4,arg5);
14938
14939 wxPyEndAllowThreads(__tstate);
14940 if (PyErr_Occurred()) SWIG_fail;
14941 }
14942 Py_INCREF(Py_None); resultobj = Py_None;
14943 {
14944 if (arg3) delete [] arg3;
14945 }
14946 return resultobj;
14947 fail:
14948 {
14949 if (arg3) delete [] arg3;
14950 }
14951 return NULL;
14952 }
14953
14954
14955 static PyObject *_wrap_DC_DrawPolygon(PyObject *, PyObject *args, PyObject *kwargs) {
14956 PyObject *resultobj;
14957 wxDC *arg1 = (wxDC *) 0 ;
14958 int arg2 ;
14959 wxPoint *arg3 = (wxPoint *) 0 ;
14960 int arg4 = (int) 0 ;
14961 int arg5 = (int) 0 ;
14962 int arg6 = (int) wxODDEVEN_RULE ;
14963 PyObject * obj0 = 0 ;
14964 PyObject * obj1 = 0 ;
14965 PyObject * obj2 = 0 ;
14966 PyObject * obj3 = 0 ;
14967 PyObject * obj4 = 0 ;
14968 char *kwnames[] = {
14969 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset",(char *) "fillStyle", NULL
14970 };
14971
14972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DC_DrawPolygon",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14974 if (SWIG_arg_fail(1)) SWIG_fail;
14975 {
14976 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14977 if (arg3 == NULL) SWIG_fail;
14978 }
14979 if (obj2) {
14980 {
14981 arg4 = (int)(SWIG_As_int(obj2));
14982 if (SWIG_arg_fail(4)) SWIG_fail;
14983 }
14984 }
14985 if (obj3) {
14986 {
14987 arg5 = (int)(SWIG_As_int(obj3));
14988 if (SWIG_arg_fail(5)) SWIG_fail;
14989 }
14990 }
14991 if (obj4) {
14992 {
14993 arg6 = (int)(SWIG_As_int(obj4));
14994 if (SWIG_arg_fail(6)) SWIG_fail;
14995 }
14996 }
14997 {
14998 PyThreadState* __tstate = wxPyBeginAllowThreads();
14999 (arg1)->DrawPolygon(arg2,arg3,arg4,arg5,arg6);
15000
15001 wxPyEndAllowThreads(__tstate);
15002 if (PyErr_Occurred()) SWIG_fail;
15003 }
15004 Py_INCREF(Py_None); resultobj = Py_None;
15005 {
15006 if (arg3) delete [] arg3;
15007 }
15008 return resultobj;
15009 fail:
15010 {
15011 if (arg3) delete [] arg3;
15012 }
15013 return NULL;
15014 }
15015
15016
15017 static PyObject *_wrap_DC_DrawLabel(PyObject *, PyObject *args, PyObject *kwargs) {
15018 PyObject *resultobj;
15019 wxDC *arg1 = (wxDC *) 0 ;
15020 wxString *arg2 = 0 ;
15021 wxRect *arg3 = 0 ;
15022 int arg4 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
15023 int arg5 = (int) -1 ;
15024 bool temp2 = false ;
15025 wxRect temp3 ;
15026 PyObject * obj0 = 0 ;
15027 PyObject * obj1 = 0 ;
15028 PyObject * obj2 = 0 ;
15029 PyObject * obj3 = 0 ;
15030 PyObject * obj4 = 0 ;
15031 char *kwnames[] = {
15032 (char *) "self",(char *) "text",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
15033 };
15034
15035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:DC_DrawLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
15036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15037 if (SWIG_arg_fail(1)) SWIG_fail;
15038 {
15039 arg2 = wxString_in_helper(obj1);
15040 if (arg2 == NULL) SWIG_fail;
15041 temp2 = true;
15042 }
15043 {
15044 arg3 = &temp3;
15045 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
15046 }
15047 if (obj3) {
15048 {
15049 arg4 = (int)(SWIG_As_int(obj3));
15050 if (SWIG_arg_fail(4)) SWIG_fail;
15051 }
15052 }
15053 if (obj4) {
15054 {
15055 arg5 = (int)(SWIG_As_int(obj4));
15056 if (SWIG_arg_fail(5)) SWIG_fail;
15057 }
15058 }
15059 {
15060 PyThreadState* __tstate = wxPyBeginAllowThreads();
15061 (arg1)->DrawLabel((wxString const &)*arg2,(wxRect const &)*arg3,arg4,arg5);
15062
15063 wxPyEndAllowThreads(__tstate);
15064 if (PyErr_Occurred()) SWIG_fail;
15065 }
15066 Py_INCREF(Py_None); resultobj = Py_None;
15067 {
15068 if (temp2)
15069 delete arg2;
15070 }
15071 return resultobj;
15072 fail:
15073 {
15074 if (temp2)
15075 delete arg2;
15076 }
15077 return NULL;
15078 }
15079
15080
15081 static PyObject *_wrap_DC_DrawImageLabel(PyObject *, PyObject *args, PyObject *kwargs) {
15082 PyObject *resultobj;
15083 wxDC *arg1 = (wxDC *) 0 ;
15084 wxString *arg2 = 0 ;
15085 wxBitmap *arg3 = 0 ;
15086 wxRect *arg4 = 0 ;
15087 int arg5 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
15088 int arg6 = (int) -1 ;
15089 wxRect result;
15090 bool temp2 = false ;
15091 wxRect temp4 ;
15092 PyObject * obj0 = 0 ;
15093 PyObject * obj1 = 0 ;
15094 PyObject * obj2 = 0 ;
15095 PyObject * obj3 = 0 ;
15096 PyObject * obj4 = 0 ;
15097 PyObject * obj5 = 0 ;
15098 char *kwnames[] = {
15099 (char *) "self",(char *) "text",(char *) "image",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
15100 };
15101
15102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:DC_DrawImageLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
15103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15104 if (SWIG_arg_fail(1)) SWIG_fail;
15105 {
15106 arg2 = wxString_in_helper(obj1);
15107 if (arg2 == NULL) SWIG_fail;
15108 temp2 = true;
15109 }
15110 {
15111 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
15112 if (SWIG_arg_fail(3)) SWIG_fail;
15113 if (arg3 == NULL) {
15114 SWIG_null_ref("wxBitmap");
15115 }
15116 if (SWIG_arg_fail(3)) SWIG_fail;
15117 }
15118 {
15119 arg4 = &temp4;
15120 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
15121 }
15122 if (obj4) {
15123 {
15124 arg5 = (int)(SWIG_As_int(obj4));
15125 if (SWIG_arg_fail(5)) SWIG_fail;
15126 }
15127 }
15128 if (obj5) {
15129 {
15130 arg6 = (int)(SWIG_As_int(obj5));
15131 if (SWIG_arg_fail(6)) SWIG_fail;
15132 }
15133 }
15134 {
15135 PyThreadState* __tstate = wxPyBeginAllowThreads();
15136 result = wxDC_DrawImageLabel(arg1,(wxString const &)*arg2,(wxBitmap const &)*arg3,(wxRect const &)*arg4,arg5,arg6);
15137
15138 wxPyEndAllowThreads(__tstate);
15139 if (PyErr_Occurred()) SWIG_fail;
15140 }
15141 {
15142 wxRect * resultptr;
15143 resultptr = new wxRect((wxRect &)(result));
15144 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
15145 }
15146 {
15147 if (temp2)
15148 delete arg2;
15149 }
15150 return resultobj;
15151 fail:
15152 {
15153 if (temp2)
15154 delete arg2;
15155 }
15156 return NULL;
15157 }
15158
15159
15160 static PyObject *_wrap_DC_DrawSpline(PyObject *, PyObject *args, PyObject *kwargs) {
15161 PyObject *resultobj;
15162 wxDC *arg1 = (wxDC *) 0 ;
15163 int arg2 ;
15164 wxPoint *arg3 = (wxPoint *) 0 ;
15165 PyObject * obj0 = 0 ;
15166 PyObject * obj1 = 0 ;
15167 char *kwnames[] = {
15168 (char *) "self",(char *) "points", NULL
15169 };
15170
15171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawSpline",kwnames,&obj0,&obj1)) goto fail;
15172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15173 if (SWIG_arg_fail(1)) SWIG_fail;
15174 {
15175 arg3 = wxPoint_LIST_helper(obj1, &arg2);
15176 if (arg3 == NULL) SWIG_fail;
15177 }
15178 {
15179 PyThreadState* __tstate = wxPyBeginAllowThreads();
15180 (arg1)->DrawSpline(arg2,arg3);
15181
15182 wxPyEndAllowThreads(__tstate);
15183 if (PyErr_Occurred()) SWIG_fail;
15184 }
15185 Py_INCREF(Py_None); resultobj = Py_None;
15186 {
15187 if (arg3) delete [] arg3;
15188 }
15189 return resultobj;
15190 fail:
15191 {
15192 if (arg3) delete [] arg3;
15193 }
15194 return NULL;
15195 }
15196
15197
15198 static PyObject *_wrap_DC_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
15199 PyObject *resultobj;
15200 wxDC *arg1 = (wxDC *) 0 ;
15201 PyObject * obj0 = 0 ;
15202 char *kwnames[] = {
15203 (char *) "self", NULL
15204 };
15205
15206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Clear",kwnames,&obj0)) goto fail;
15207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15208 if (SWIG_arg_fail(1)) SWIG_fail;
15209 {
15210 PyThreadState* __tstate = wxPyBeginAllowThreads();
15211 (arg1)->Clear();
15212
15213 wxPyEndAllowThreads(__tstate);
15214 if (PyErr_Occurred()) SWIG_fail;
15215 }
15216 Py_INCREF(Py_None); resultobj = Py_None;
15217 return resultobj;
15218 fail:
15219 return NULL;
15220 }
15221
15222
15223 static PyObject *_wrap_DC_StartDoc(PyObject *, PyObject *args, PyObject *kwargs) {
15224 PyObject *resultobj;
15225 wxDC *arg1 = (wxDC *) 0 ;
15226 wxString *arg2 = 0 ;
15227 bool result;
15228 bool temp2 = false ;
15229 PyObject * obj0 = 0 ;
15230 PyObject * obj1 = 0 ;
15231 char *kwnames[] = {
15232 (char *) "self",(char *) "message", NULL
15233 };
15234
15235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_StartDoc",kwnames,&obj0,&obj1)) goto fail;
15236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15237 if (SWIG_arg_fail(1)) SWIG_fail;
15238 {
15239 arg2 = wxString_in_helper(obj1);
15240 if (arg2 == NULL) SWIG_fail;
15241 temp2 = true;
15242 }
15243 {
15244 PyThreadState* __tstate = wxPyBeginAllowThreads();
15245 result = (bool)(arg1)->StartDoc((wxString const &)*arg2);
15246
15247 wxPyEndAllowThreads(__tstate);
15248 if (PyErr_Occurred()) SWIG_fail;
15249 }
15250 {
15251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15252 }
15253 {
15254 if (temp2)
15255 delete arg2;
15256 }
15257 return resultobj;
15258 fail:
15259 {
15260 if (temp2)
15261 delete arg2;
15262 }
15263 return NULL;
15264 }
15265
15266
15267 static PyObject *_wrap_DC_EndDoc(PyObject *, PyObject *args, PyObject *kwargs) {
15268 PyObject *resultobj;
15269 wxDC *arg1 = (wxDC *) 0 ;
15270 PyObject * obj0 = 0 ;
15271 char *kwnames[] = {
15272 (char *) "self", NULL
15273 };
15274
15275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDoc",kwnames,&obj0)) goto fail;
15276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15277 if (SWIG_arg_fail(1)) SWIG_fail;
15278 {
15279 PyThreadState* __tstate = wxPyBeginAllowThreads();
15280 (arg1)->EndDoc();
15281
15282 wxPyEndAllowThreads(__tstate);
15283 if (PyErr_Occurred()) SWIG_fail;
15284 }
15285 Py_INCREF(Py_None); resultobj = Py_None;
15286 return resultobj;
15287 fail:
15288 return NULL;
15289 }
15290
15291
15292 static PyObject *_wrap_DC_StartPage(PyObject *, PyObject *args, PyObject *kwargs) {
15293 PyObject *resultobj;
15294 wxDC *arg1 = (wxDC *) 0 ;
15295 PyObject * obj0 = 0 ;
15296 char *kwnames[] = {
15297 (char *) "self", NULL
15298 };
15299
15300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_StartPage",kwnames,&obj0)) goto fail;
15301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15302 if (SWIG_arg_fail(1)) SWIG_fail;
15303 {
15304 PyThreadState* __tstate = wxPyBeginAllowThreads();
15305 (arg1)->StartPage();
15306
15307 wxPyEndAllowThreads(__tstate);
15308 if (PyErr_Occurred()) SWIG_fail;
15309 }
15310 Py_INCREF(Py_None); resultobj = Py_None;
15311 return resultobj;
15312 fail:
15313 return NULL;
15314 }
15315
15316
15317 static PyObject *_wrap_DC_EndPage(PyObject *, PyObject *args, PyObject *kwargs) {
15318 PyObject *resultobj;
15319 wxDC *arg1 = (wxDC *) 0 ;
15320 PyObject * obj0 = 0 ;
15321 char *kwnames[] = {
15322 (char *) "self", NULL
15323 };
15324
15325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndPage",kwnames,&obj0)) goto fail;
15326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15327 if (SWIG_arg_fail(1)) SWIG_fail;
15328 {
15329 PyThreadState* __tstate = wxPyBeginAllowThreads();
15330 (arg1)->EndPage();
15331
15332 wxPyEndAllowThreads(__tstate);
15333 if (PyErr_Occurred()) SWIG_fail;
15334 }
15335 Py_INCREF(Py_None); resultobj = Py_None;
15336 return resultobj;
15337 fail:
15338 return NULL;
15339 }
15340
15341
15342 static PyObject *_wrap_DC_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
15343 PyObject *resultobj;
15344 wxDC *arg1 = (wxDC *) 0 ;
15345 wxFont *arg2 = 0 ;
15346 PyObject * obj0 = 0 ;
15347 PyObject * obj1 = 0 ;
15348 char *kwnames[] = {
15349 (char *) "self",(char *) "font", NULL
15350 };
15351
15352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetFont",kwnames,&obj0,&obj1)) goto fail;
15353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15354 if (SWIG_arg_fail(1)) SWIG_fail;
15355 {
15356 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15357 if (SWIG_arg_fail(2)) SWIG_fail;
15358 if (arg2 == NULL) {
15359 SWIG_null_ref("wxFont");
15360 }
15361 if (SWIG_arg_fail(2)) SWIG_fail;
15362 }
15363 {
15364 PyThreadState* __tstate = wxPyBeginAllowThreads();
15365 (arg1)->SetFont((wxFont const &)*arg2);
15366
15367 wxPyEndAllowThreads(__tstate);
15368 if (PyErr_Occurred()) SWIG_fail;
15369 }
15370 Py_INCREF(Py_None); resultobj = Py_None;
15371 return resultobj;
15372 fail:
15373 return NULL;
15374 }
15375
15376
15377 static PyObject *_wrap_DC_SetPen(PyObject *, PyObject *args, PyObject *kwargs) {
15378 PyObject *resultobj;
15379 wxDC *arg1 = (wxDC *) 0 ;
15380 wxPen *arg2 = 0 ;
15381 PyObject * obj0 = 0 ;
15382 PyObject * obj1 = 0 ;
15383 char *kwnames[] = {
15384 (char *) "self",(char *) "pen", NULL
15385 };
15386
15387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPen",kwnames,&obj0,&obj1)) goto fail;
15388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15389 if (SWIG_arg_fail(1)) SWIG_fail;
15390 {
15391 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
15392 if (SWIG_arg_fail(2)) SWIG_fail;
15393 if (arg2 == NULL) {
15394 SWIG_null_ref("wxPen");
15395 }
15396 if (SWIG_arg_fail(2)) SWIG_fail;
15397 }
15398 {
15399 PyThreadState* __tstate = wxPyBeginAllowThreads();
15400 (arg1)->SetPen((wxPen const &)*arg2);
15401
15402 wxPyEndAllowThreads(__tstate);
15403 if (PyErr_Occurred()) SWIG_fail;
15404 }
15405 Py_INCREF(Py_None); resultobj = Py_None;
15406 return resultobj;
15407 fail:
15408 return NULL;
15409 }
15410
15411
15412 static PyObject *_wrap_DC_SetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
15413 PyObject *resultobj;
15414 wxDC *arg1 = (wxDC *) 0 ;
15415 wxBrush *arg2 = 0 ;
15416 PyObject * obj0 = 0 ;
15417 PyObject * obj1 = 0 ;
15418 char *kwnames[] = {
15419 (char *) "self",(char *) "brush", NULL
15420 };
15421
15422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBrush",kwnames,&obj0,&obj1)) goto fail;
15423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15424 if (SWIG_arg_fail(1)) SWIG_fail;
15425 {
15426 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
15427 if (SWIG_arg_fail(2)) SWIG_fail;
15428 if (arg2 == NULL) {
15429 SWIG_null_ref("wxBrush");
15430 }
15431 if (SWIG_arg_fail(2)) SWIG_fail;
15432 }
15433 {
15434 PyThreadState* __tstate = wxPyBeginAllowThreads();
15435 (arg1)->SetBrush((wxBrush const &)*arg2);
15436
15437 wxPyEndAllowThreads(__tstate);
15438 if (PyErr_Occurred()) SWIG_fail;
15439 }
15440 Py_INCREF(Py_None); resultobj = Py_None;
15441 return resultobj;
15442 fail:
15443 return NULL;
15444 }
15445
15446
15447 static PyObject *_wrap_DC_SetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15448 PyObject *resultobj;
15449 wxDC *arg1 = (wxDC *) 0 ;
15450 wxBrush *arg2 = 0 ;
15451 PyObject * obj0 = 0 ;
15452 PyObject * obj1 = 0 ;
15453 char *kwnames[] = {
15454 (char *) "self",(char *) "brush", NULL
15455 };
15456
15457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackground",kwnames,&obj0,&obj1)) goto fail;
15458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15459 if (SWIG_arg_fail(1)) SWIG_fail;
15460 {
15461 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
15462 if (SWIG_arg_fail(2)) SWIG_fail;
15463 if (arg2 == NULL) {
15464 SWIG_null_ref("wxBrush");
15465 }
15466 if (SWIG_arg_fail(2)) SWIG_fail;
15467 }
15468 {
15469 PyThreadState* __tstate = wxPyBeginAllowThreads();
15470 (arg1)->SetBackground((wxBrush const &)*arg2);
15471
15472 wxPyEndAllowThreads(__tstate);
15473 if (PyErr_Occurred()) SWIG_fail;
15474 }
15475 Py_INCREF(Py_None); resultobj = Py_None;
15476 return resultobj;
15477 fail:
15478 return NULL;
15479 }
15480
15481
15482 static PyObject *_wrap_DC_SetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
15483 PyObject *resultobj;
15484 wxDC *arg1 = (wxDC *) 0 ;
15485 int arg2 ;
15486 PyObject * obj0 = 0 ;
15487 PyObject * obj1 = 0 ;
15488 char *kwnames[] = {
15489 (char *) "self",(char *) "mode", NULL
15490 };
15491
15492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackgroundMode",kwnames,&obj0,&obj1)) goto fail;
15493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15494 if (SWIG_arg_fail(1)) SWIG_fail;
15495 {
15496 arg2 = (int)(SWIG_As_int(obj1));
15497 if (SWIG_arg_fail(2)) SWIG_fail;
15498 }
15499 {
15500 PyThreadState* __tstate = wxPyBeginAllowThreads();
15501 (arg1)->SetBackgroundMode(arg2);
15502
15503 wxPyEndAllowThreads(__tstate);
15504 if (PyErr_Occurred()) SWIG_fail;
15505 }
15506 Py_INCREF(Py_None); resultobj = Py_None;
15507 return resultobj;
15508 fail:
15509 return NULL;
15510 }
15511
15512
15513 static PyObject *_wrap_DC_SetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
15514 PyObject *resultobj;
15515 wxDC *arg1 = (wxDC *) 0 ;
15516 wxPalette *arg2 = 0 ;
15517 PyObject * obj0 = 0 ;
15518 PyObject * obj1 = 0 ;
15519 char *kwnames[] = {
15520 (char *) "self",(char *) "palette", NULL
15521 };
15522
15523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPalette",kwnames,&obj0,&obj1)) goto fail;
15524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15525 if (SWIG_arg_fail(1)) SWIG_fail;
15526 {
15527 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
15528 if (SWIG_arg_fail(2)) SWIG_fail;
15529 if (arg2 == NULL) {
15530 SWIG_null_ref("wxPalette");
15531 }
15532 if (SWIG_arg_fail(2)) SWIG_fail;
15533 }
15534 {
15535 PyThreadState* __tstate = wxPyBeginAllowThreads();
15536 (arg1)->SetPalette((wxPalette const &)*arg2);
15537
15538 wxPyEndAllowThreads(__tstate);
15539 if (PyErr_Occurred()) SWIG_fail;
15540 }
15541 Py_INCREF(Py_None); resultobj = Py_None;
15542 return resultobj;
15543 fail:
15544 return NULL;
15545 }
15546
15547
15548 static PyObject *_wrap_DC_DestroyClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
15549 PyObject *resultobj;
15550 wxDC *arg1 = (wxDC *) 0 ;
15551 PyObject * obj0 = 0 ;
15552 char *kwnames[] = {
15553 (char *) "self", NULL
15554 };
15555
15556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_DestroyClippingRegion",kwnames,&obj0)) goto fail;
15557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15558 if (SWIG_arg_fail(1)) SWIG_fail;
15559 {
15560 PyThreadState* __tstate = wxPyBeginAllowThreads();
15561 (arg1)->DestroyClippingRegion();
15562
15563 wxPyEndAllowThreads(__tstate);
15564 if (PyErr_Occurred()) SWIG_fail;
15565 }
15566 Py_INCREF(Py_None); resultobj = Py_None;
15567 return resultobj;
15568 fail:
15569 return NULL;
15570 }
15571
15572
15573 static PyObject *_wrap_DC_GetClippingBox(PyObject *, PyObject *args, PyObject *kwargs) {
15574 PyObject *resultobj;
15575 wxDC *arg1 = (wxDC *) 0 ;
15576 int *arg2 = (int *) 0 ;
15577 int *arg3 = (int *) 0 ;
15578 int *arg4 = (int *) 0 ;
15579 int *arg5 = (int *) 0 ;
15580 int temp2 ;
15581 int res2 = 0 ;
15582 int temp3 ;
15583 int res3 = 0 ;
15584 int temp4 ;
15585 int res4 = 0 ;
15586 int temp5 ;
15587 int res5 = 0 ;
15588 PyObject * obj0 = 0 ;
15589 char *kwnames[] = {
15590 (char *) "self", NULL
15591 };
15592
15593 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15594 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15595 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15596 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingBox",kwnames,&obj0)) goto fail;
15598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15599 if (SWIG_arg_fail(1)) SWIG_fail;
15600 {
15601 PyThreadState* __tstate = wxPyBeginAllowThreads();
15602 ((wxDC const *)arg1)->GetClippingBox(arg2,arg3,arg4,arg5);
15603
15604 wxPyEndAllowThreads(__tstate);
15605 if (PyErr_Occurred()) SWIG_fail;
15606 }
15607 Py_INCREF(Py_None); resultobj = Py_None;
15608 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15609 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15610 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15611 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15612 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15613 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15614 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15615 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15616 return resultobj;
15617 fail:
15618 return NULL;
15619 }
15620
15621
15622 static PyObject *_wrap_DC_GetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
15623 PyObject *resultobj;
15624 wxDC *arg1 = (wxDC *) 0 ;
15625 wxRect result;
15626 PyObject * obj0 = 0 ;
15627 char *kwnames[] = {
15628 (char *) "self", NULL
15629 };
15630
15631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingRect",kwnames,&obj0)) goto fail;
15632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15633 if (SWIG_arg_fail(1)) SWIG_fail;
15634 {
15635 PyThreadState* __tstate = wxPyBeginAllowThreads();
15636 result = wxDC_GetClippingRect(arg1);
15637
15638 wxPyEndAllowThreads(__tstate);
15639 if (PyErr_Occurred()) SWIG_fail;
15640 }
15641 {
15642 wxRect * resultptr;
15643 resultptr = new wxRect((wxRect &)(result));
15644 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
15645 }
15646 return resultobj;
15647 fail:
15648 return NULL;
15649 }
15650
15651
15652 static PyObject *_wrap_DC_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
15653 PyObject *resultobj;
15654 wxDC *arg1 = (wxDC *) 0 ;
15655 int result;
15656 PyObject * obj0 = 0 ;
15657 char *kwnames[] = {
15658 (char *) "self", NULL
15659 };
15660
15661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharHeight",kwnames,&obj0)) goto fail;
15662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15663 if (SWIG_arg_fail(1)) SWIG_fail;
15664 {
15665 PyThreadState* __tstate = wxPyBeginAllowThreads();
15666 result = (int)((wxDC const *)arg1)->GetCharHeight();
15667
15668 wxPyEndAllowThreads(__tstate);
15669 if (PyErr_Occurred()) SWIG_fail;
15670 }
15671 {
15672 resultobj = SWIG_From_int((int)(result));
15673 }
15674 return resultobj;
15675 fail:
15676 return NULL;
15677 }
15678
15679
15680 static PyObject *_wrap_DC_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
15681 PyObject *resultobj;
15682 wxDC *arg1 = (wxDC *) 0 ;
15683 int result;
15684 PyObject * obj0 = 0 ;
15685 char *kwnames[] = {
15686 (char *) "self", NULL
15687 };
15688
15689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharWidth",kwnames,&obj0)) goto fail;
15690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15691 if (SWIG_arg_fail(1)) SWIG_fail;
15692 {
15693 PyThreadState* __tstate = wxPyBeginAllowThreads();
15694 result = (int)((wxDC const *)arg1)->GetCharWidth();
15695
15696 wxPyEndAllowThreads(__tstate);
15697 if (PyErr_Occurred()) SWIG_fail;
15698 }
15699 {
15700 resultobj = SWIG_From_int((int)(result));
15701 }
15702 return resultobj;
15703 fail:
15704 return NULL;
15705 }
15706
15707
15708 static PyObject *_wrap_DC_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15709 PyObject *resultobj;
15710 wxDC *arg1 = (wxDC *) 0 ;
15711 wxString *arg2 = 0 ;
15712 int *arg3 = (int *) 0 ;
15713 int *arg4 = (int *) 0 ;
15714 bool temp2 = false ;
15715 int temp3 ;
15716 int res3 = 0 ;
15717 int temp4 ;
15718 int res4 = 0 ;
15719 PyObject * obj0 = 0 ;
15720 PyObject * obj1 = 0 ;
15721 char *kwnames[] = {
15722 (char *) "self",(char *) "string", NULL
15723 };
15724
15725 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15726 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
15728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15729 if (SWIG_arg_fail(1)) SWIG_fail;
15730 {
15731 arg2 = wxString_in_helper(obj1);
15732 if (arg2 == NULL) SWIG_fail;
15733 temp2 = true;
15734 }
15735 {
15736 PyThreadState* __tstate = wxPyBeginAllowThreads();
15737 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
15738
15739 wxPyEndAllowThreads(__tstate);
15740 if (PyErr_Occurred()) SWIG_fail;
15741 }
15742 Py_INCREF(Py_None); resultobj = Py_None;
15743 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15744 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15745 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15746 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15747 {
15748 if (temp2)
15749 delete arg2;
15750 }
15751 return resultobj;
15752 fail:
15753 {
15754 if (temp2)
15755 delete arg2;
15756 }
15757 return NULL;
15758 }
15759
15760
15761 static PyObject *_wrap_DC_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15762 PyObject *resultobj;
15763 wxDC *arg1 = (wxDC *) 0 ;
15764 wxString *arg2 = 0 ;
15765 int *arg3 = (int *) 0 ;
15766 int *arg4 = (int *) 0 ;
15767 int *arg5 = (int *) 0 ;
15768 int *arg6 = (int *) 0 ;
15769 wxFont *arg7 = (wxFont *) NULL ;
15770 bool temp2 = false ;
15771 int temp3 ;
15772 int res3 = 0 ;
15773 int temp4 ;
15774 int res4 = 0 ;
15775 int temp5 ;
15776 int res5 = 0 ;
15777 int temp6 ;
15778 int res6 = 0 ;
15779 PyObject * obj0 = 0 ;
15780 PyObject * obj1 = 0 ;
15781 PyObject * obj2 = 0 ;
15782 char *kwnames[] = {
15783 (char *) "self",(char *) "string",(char *) "font", NULL
15784 };
15785
15786 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15787 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15788 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15789 arg6 = &temp6; res6 = SWIG_NEWOBJ;
15790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15792 if (SWIG_arg_fail(1)) SWIG_fail;
15793 {
15794 arg2 = wxString_in_helper(obj1);
15795 if (arg2 == NULL) SWIG_fail;
15796 temp2 = true;
15797 }
15798 if (obj2) {
15799 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15800 if (SWIG_arg_fail(7)) SWIG_fail;
15801 }
15802 {
15803 PyThreadState* __tstate = wxPyBeginAllowThreads();
15804 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
15805
15806 wxPyEndAllowThreads(__tstate);
15807 if (PyErr_Occurred()) SWIG_fail;
15808 }
15809 Py_INCREF(Py_None); resultobj = Py_None;
15810 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15811 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15812 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15813 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15814 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15815 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15816 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
15817 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
15818 {
15819 if (temp2)
15820 delete arg2;
15821 }
15822 return resultobj;
15823 fail:
15824 {
15825 if (temp2)
15826 delete arg2;
15827 }
15828 return NULL;
15829 }
15830
15831
15832 static PyObject *_wrap_DC_GetMultiLineTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15833 PyObject *resultobj;
15834 wxDC *arg1 = (wxDC *) 0 ;
15835 wxString *arg2 = 0 ;
15836 int *arg3 = (int *) 0 ;
15837 int *arg4 = (int *) 0 ;
15838 int *arg5 = (int *) 0 ;
15839 wxFont *arg6 = (wxFont *) NULL ;
15840 bool temp2 = false ;
15841 int temp3 ;
15842 int res3 = 0 ;
15843 int temp4 ;
15844 int res4 = 0 ;
15845 int temp5 ;
15846 int res5 = 0 ;
15847 PyObject * obj0 = 0 ;
15848 PyObject * obj1 = 0 ;
15849 PyObject * obj2 = 0 ;
15850 char *kwnames[] = {
15851 (char *) "self",(char *) "text",(char *) "font", NULL
15852 };
15853
15854 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15855 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15856 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetMultiLineTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15859 if (SWIG_arg_fail(1)) SWIG_fail;
15860 {
15861 arg2 = wxString_in_helper(obj1);
15862 if (arg2 == NULL) SWIG_fail;
15863 temp2 = true;
15864 }
15865 if (obj2) {
15866 SWIG_Python_ConvertPtr(obj2, (void **)&arg6, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15867 if (SWIG_arg_fail(6)) SWIG_fail;
15868 }
15869 {
15870 PyThreadState* __tstate = wxPyBeginAllowThreads();
15871 (arg1)->GetMultiLineTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6);
15872
15873 wxPyEndAllowThreads(__tstate);
15874 if (PyErr_Occurred()) SWIG_fail;
15875 }
15876 Py_INCREF(Py_None); resultobj = Py_None;
15877 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15878 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15879 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15880 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15881 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15882 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15883 {
15884 if (temp2)
15885 delete arg2;
15886 }
15887 return resultobj;
15888 fail:
15889 {
15890 if (temp2)
15891 delete arg2;
15892 }
15893 return NULL;
15894 }
15895
15896
15897 static PyObject *_wrap_DC_GetPartialTextExtents(PyObject *, PyObject *args, PyObject *kwargs) {
15898 PyObject *resultobj;
15899 wxDC *arg1 = (wxDC *) 0 ;
15900 wxString *arg2 = 0 ;
15901 wxArrayInt result;
15902 bool temp2 = false ;
15903 PyObject * obj0 = 0 ;
15904 PyObject * obj1 = 0 ;
15905 char *kwnames[] = {
15906 (char *) "self",(char *) "text", NULL
15907 };
15908
15909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPartialTextExtents",kwnames,&obj0,&obj1)) goto fail;
15910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15911 if (SWIG_arg_fail(1)) SWIG_fail;
15912 {
15913 arg2 = wxString_in_helper(obj1);
15914 if (arg2 == NULL) SWIG_fail;
15915 temp2 = true;
15916 }
15917 {
15918 PyThreadState* __tstate = wxPyBeginAllowThreads();
15919 result = wxDC_GetPartialTextExtents(arg1,(wxString const &)*arg2);
15920
15921 wxPyEndAllowThreads(__tstate);
15922 if (PyErr_Occurred()) SWIG_fail;
15923 }
15924 {
15925 resultobj = PyList_New(0);
15926 size_t idx;
15927 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15928 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15929 PyList_Append(resultobj, val);
15930 Py_DECREF(val);
15931 }
15932 }
15933 {
15934 if (temp2)
15935 delete arg2;
15936 }
15937 return resultobj;
15938 fail:
15939 {
15940 if (temp2)
15941 delete arg2;
15942 }
15943 return NULL;
15944 }
15945
15946
15947 static PyObject *_wrap_DC_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
15948 PyObject *resultobj;
15949 wxDC *arg1 = (wxDC *) 0 ;
15950 wxSize result;
15951 PyObject * obj0 = 0 ;
15952 char *kwnames[] = {
15953 (char *) "self", NULL
15954 };
15955
15956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSize",kwnames,&obj0)) goto fail;
15957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15958 if (SWIG_arg_fail(1)) SWIG_fail;
15959 {
15960 PyThreadState* __tstate = wxPyBeginAllowThreads();
15961 result = (arg1)->GetSize();
15962
15963 wxPyEndAllowThreads(__tstate);
15964 if (PyErr_Occurred()) SWIG_fail;
15965 }
15966 {
15967 wxSize * resultptr;
15968 resultptr = new wxSize((wxSize &)(result));
15969 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15970 }
15971 return resultobj;
15972 fail:
15973 return NULL;
15974 }
15975
15976
15977 static PyObject *_wrap_DC_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15978 PyObject *resultobj;
15979 wxDC *arg1 = (wxDC *) 0 ;
15980 int *arg2 = (int *) 0 ;
15981 int *arg3 = (int *) 0 ;
15982 int temp2 ;
15983 int res2 = 0 ;
15984 int temp3 ;
15985 int res3 = 0 ;
15986 PyObject * obj0 = 0 ;
15987 char *kwnames[] = {
15988 (char *) "self", NULL
15989 };
15990
15991 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15992 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeTuple",kwnames,&obj0)) goto fail;
15994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15995 if (SWIG_arg_fail(1)) SWIG_fail;
15996 {
15997 PyThreadState* __tstate = wxPyBeginAllowThreads();
15998 (arg1)->GetSize(arg2,arg3);
15999
16000 wxPyEndAllowThreads(__tstate);
16001 if (PyErr_Occurred()) SWIG_fail;
16002 }
16003 Py_INCREF(Py_None); resultobj = Py_None;
16004 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16005 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16006 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16007 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16008 return resultobj;
16009 fail:
16010 return NULL;
16011 }
16012
16013
16014 static PyObject *_wrap_DC_GetSizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
16015 PyObject *resultobj;
16016 wxDC *arg1 = (wxDC *) 0 ;
16017 wxSize result;
16018 PyObject * obj0 = 0 ;
16019 char *kwnames[] = {
16020 (char *) "self", NULL
16021 };
16022
16023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMM",kwnames,&obj0)) goto fail;
16024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16025 if (SWIG_arg_fail(1)) SWIG_fail;
16026 {
16027 PyThreadState* __tstate = wxPyBeginAllowThreads();
16028 result = ((wxDC const *)arg1)->GetSizeMM();
16029
16030 wxPyEndAllowThreads(__tstate);
16031 if (PyErr_Occurred()) SWIG_fail;
16032 }
16033 {
16034 wxSize * resultptr;
16035 resultptr = new wxSize((wxSize &)(result));
16036 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16037 }
16038 return resultobj;
16039 fail:
16040 return NULL;
16041 }
16042
16043
16044 static PyObject *_wrap_DC_GetSizeMMTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16045 PyObject *resultobj;
16046 wxDC *arg1 = (wxDC *) 0 ;
16047 int *arg2 = (int *) 0 ;
16048 int *arg3 = (int *) 0 ;
16049 int temp2 ;
16050 int res2 = 0 ;
16051 int temp3 ;
16052 int res3 = 0 ;
16053 PyObject * obj0 = 0 ;
16054 char *kwnames[] = {
16055 (char *) "self", NULL
16056 };
16057
16058 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16059 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMMTuple",kwnames,&obj0)) goto fail;
16061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16062 if (SWIG_arg_fail(1)) SWIG_fail;
16063 {
16064 PyThreadState* __tstate = wxPyBeginAllowThreads();
16065 ((wxDC const *)arg1)->GetSizeMM(arg2,arg3);
16066
16067 wxPyEndAllowThreads(__tstate);
16068 if (PyErr_Occurred()) SWIG_fail;
16069 }
16070 Py_INCREF(Py_None); resultobj = Py_None;
16071 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16072 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16073 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16074 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16075 return resultobj;
16076 fail:
16077 return NULL;
16078 }
16079
16080
16081 static PyObject *_wrap_DC_DeviceToLogicalX(PyObject *, PyObject *args, PyObject *kwargs) {
16082 PyObject *resultobj;
16083 wxDC *arg1 = (wxDC *) 0 ;
16084 int arg2 ;
16085 int result;
16086 PyObject * obj0 = 0 ;
16087 PyObject * obj1 = 0 ;
16088 char *kwnames[] = {
16089 (char *) "self",(char *) "x", NULL
16090 };
16091
16092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalX",kwnames,&obj0,&obj1)) goto fail;
16093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16094 if (SWIG_arg_fail(1)) SWIG_fail;
16095 {
16096 arg2 = (int)(SWIG_As_int(obj1));
16097 if (SWIG_arg_fail(2)) SWIG_fail;
16098 }
16099 {
16100 PyThreadState* __tstate = wxPyBeginAllowThreads();
16101 result = (int)((wxDC const *)arg1)->DeviceToLogicalX(arg2);
16102
16103 wxPyEndAllowThreads(__tstate);
16104 if (PyErr_Occurred()) SWIG_fail;
16105 }
16106 {
16107 resultobj = SWIG_From_int((int)(result));
16108 }
16109 return resultobj;
16110 fail:
16111 return NULL;
16112 }
16113
16114
16115 static PyObject *_wrap_DC_DeviceToLogicalY(PyObject *, PyObject *args, PyObject *kwargs) {
16116 PyObject *resultobj;
16117 wxDC *arg1 = (wxDC *) 0 ;
16118 int arg2 ;
16119 int result;
16120 PyObject * obj0 = 0 ;
16121 PyObject * obj1 = 0 ;
16122 char *kwnames[] = {
16123 (char *) "self",(char *) "y", NULL
16124 };
16125
16126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalY",kwnames,&obj0,&obj1)) goto fail;
16127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16128 if (SWIG_arg_fail(1)) SWIG_fail;
16129 {
16130 arg2 = (int)(SWIG_As_int(obj1));
16131 if (SWIG_arg_fail(2)) SWIG_fail;
16132 }
16133 {
16134 PyThreadState* __tstate = wxPyBeginAllowThreads();
16135 result = (int)((wxDC const *)arg1)->DeviceToLogicalY(arg2);
16136
16137 wxPyEndAllowThreads(__tstate);
16138 if (PyErr_Occurred()) SWIG_fail;
16139 }
16140 {
16141 resultobj = SWIG_From_int((int)(result));
16142 }
16143 return resultobj;
16144 fail:
16145 return NULL;
16146 }
16147
16148
16149 static PyObject *_wrap_DC_DeviceToLogicalXRel(PyObject *, PyObject *args, PyObject *kwargs) {
16150 PyObject *resultobj;
16151 wxDC *arg1 = (wxDC *) 0 ;
16152 int arg2 ;
16153 int result;
16154 PyObject * obj0 = 0 ;
16155 PyObject * obj1 = 0 ;
16156 char *kwnames[] = {
16157 (char *) "self",(char *) "x", NULL
16158 };
16159
16160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalXRel",kwnames,&obj0,&obj1)) goto fail;
16161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16162 if (SWIG_arg_fail(1)) SWIG_fail;
16163 {
16164 arg2 = (int)(SWIG_As_int(obj1));
16165 if (SWIG_arg_fail(2)) SWIG_fail;
16166 }
16167 {
16168 PyThreadState* __tstate = wxPyBeginAllowThreads();
16169 result = (int)((wxDC const *)arg1)->DeviceToLogicalXRel(arg2);
16170
16171 wxPyEndAllowThreads(__tstate);
16172 if (PyErr_Occurred()) SWIG_fail;
16173 }
16174 {
16175 resultobj = SWIG_From_int((int)(result));
16176 }
16177 return resultobj;
16178 fail:
16179 return NULL;
16180 }
16181
16182
16183 static PyObject *_wrap_DC_DeviceToLogicalYRel(PyObject *, PyObject *args, PyObject *kwargs) {
16184 PyObject *resultobj;
16185 wxDC *arg1 = (wxDC *) 0 ;
16186 int arg2 ;
16187 int result;
16188 PyObject * obj0 = 0 ;
16189 PyObject * obj1 = 0 ;
16190 char *kwnames[] = {
16191 (char *) "self",(char *) "y", NULL
16192 };
16193
16194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalYRel",kwnames,&obj0,&obj1)) goto fail;
16195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16196 if (SWIG_arg_fail(1)) SWIG_fail;
16197 {
16198 arg2 = (int)(SWIG_As_int(obj1));
16199 if (SWIG_arg_fail(2)) SWIG_fail;
16200 }
16201 {
16202 PyThreadState* __tstate = wxPyBeginAllowThreads();
16203 result = (int)((wxDC const *)arg1)->DeviceToLogicalYRel(arg2);
16204
16205 wxPyEndAllowThreads(__tstate);
16206 if (PyErr_Occurred()) SWIG_fail;
16207 }
16208 {
16209 resultobj = SWIG_From_int((int)(result));
16210 }
16211 return resultobj;
16212 fail:
16213 return NULL;
16214 }
16215
16216
16217 static PyObject *_wrap_DC_LogicalToDeviceX(PyObject *, PyObject *args, PyObject *kwargs) {
16218 PyObject *resultobj;
16219 wxDC *arg1 = (wxDC *) 0 ;
16220 int arg2 ;
16221 int result;
16222 PyObject * obj0 = 0 ;
16223 PyObject * obj1 = 0 ;
16224 char *kwnames[] = {
16225 (char *) "self",(char *) "x", NULL
16226 };
16227
16228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceX",kwnames,&obj0,&obj1)) goto fail;
16229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16230 if (SWIG_arg_fail(1)) SWIG_fail;
16231 {
16232 arg2 = (int)(SWIG_As_int(obj1));
16233 if (SWIG_arg_fail(2)) SWIG_fail;
16234 }
16235 {
16236 PyThreadState* __tstate = wxPyBeginAllowThreads();
16237 result = (int)((wxDC const *)arg1)->LogicalToDeviceX(arg2);
16238
16239 wxPyEndAllowThreads(__tstate);
16240 if (PyErr_Occurred()) SWIG_fail;
16241 }
16242 {
16243 resultobj = SWIG_From_int((int)(result));
16244 }
16245 return resultobj;
16246 fail:
16247 return NULL;
16248 }
16249
16250
16251 static PyObject *_wrap_DC_LogicalToDeviceY(PyObject *, PyObject *args, PyObject *kwargs) {
16252 PyObject *resultobj;
16253 wxDC *arg1 = (wxDC *) 0 ;
16254 int arg2 ;
16255 int result;
16256 PyObject * obj0 = 0 ;
16257 PyObject * obj1 = 0 ;
16258 char *kwnames[] = {
16259 (char *) "self",(char *) "y", NULL
16260 };
16261
16262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceY",kwnames,&obj0,&obj1)) goto fail;
16263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16264 if (SWIG_arg_fail(1)) SWIG_fail;
16265 {
16266 arg2 = (int)(SWIG_As_int(obj1));
16267 if (SWIG_arg_fail(2)) SWIG_fail;
16268 }
16269 {
16270 PyThreadState* __tstate = wxPyBeginAllowThreads();
16271 result = (int)((wxDC const *)arg1)->LogicalToDeviceY(arg2);
16272
16273 wxPyEndAllowThreads(__tstate);
16274 if (PyErr_Occurred()) SWIG_fail;
16275 }
16276 {
16277 resultobj = SWIG_From_int((int)(result));
16278 }
16279 return resultobj;
16280 fail:
16281 return NULL;
16282 }
16283
16284
16285 static PyObject *_wrap_DC_LogicalToDeviceXRel(PyObject *, PyObject *args, PyObject *kwargs) {
16286 PyObject *resultobj;
16287 wxDC *arg1 = (wxDC *) 0 ;
16288 int arg2 ;
16289 int result;
16290 PyObject * obj0 = 0 ;
16291 PyObject * obj1 = 0 ;
16292 char *kwnames[] = {
16293 (char *) "self",(char *) "x", NULL
16294 };
16295
16296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceXRel",kwnames,&obj0,&obj1)) goto fail;
16297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16298 if (SWIG_arg_fail(1)) SWIG_fail;
16299 {
16300 arg2 = (int)(SWIG_As_int(obj1));
16301 if (SWIG_arg_fail(2)) SWIG_fail;
16302 }
16303 {
16304 PyThreadState* __tstate = wxPyBeginAllowThreads();
16305 result = (int)((wxDC const *)arg1)->LogicalToDeviceXRel(arg2);
16306
16307 wxPyEndAllowThreads(__tstate);
16308 if (PyErr_Occurred()) SWIG_fail;
16309 }
16310 {
16311 resultobj = SWIG_From_int((int)(result));
16312 }
16313 return resultobj;
16314 fail:
16315 return NULL;
16316 }
16317
16318
16319 static PyObject *_wrap_DC_LogicalToDeviceYRel(PyObject *, PyObject *args, PyObject *kwargs) {
16320 PyObject *resultobj;
16321 wxDC *arg1 = (wxDC *) 0 ;
16322 int arg2 ;
16323 int result;
16324 PyObject * obj0 = 0 ;
16325 PyObject * obj1 = 0 ;
16326 char *kwnames[] = {
16327 (char *) "self",(char *) "y", NULL
16328 };
16329
16330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceYRel",kwnames,&obj0,&obj1)) goto fail;
16331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16332 if (SWIG_arg_fail(1)) SWIG_fail;
16333 {
16334 arg2 = (int)(SWIG_As_int(obj1));
16335 if (SWIG_arg_fail(2)) SWIG_fail;
16336 }
16337 {
16338 PyThreadState* __tstate = wxPyBeginAllowThreads();
16339 result = (int)((wxDC const *)arg1)->LogicalToDeviceYRel(arg2);
16340
16341 wxPyEndAllowThreads(__tstate);
16342 if (PyErr_Occurred()) SWIG_fail;
16343 }
16344 {
16345 resultobj = SWIG_From_int((int)(result));
16346 }
16347 return resultobj;
16348 fail:
16349 return NULL;
16350 }
16351
16352
16353 static PyObject *_wrap_DC_CanDrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16354 PyObject *resultobj;
16355 wxDC *arg1 = (wxDC *) 0 ;
16356 bool result;
16357 PyObject * obj0 = 0 ;
16358 char *kwnames[] = {
16359 (char *) "self", NULL
16360 };
16361
16362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanDrawBitmap",kwnames,&obj0)) goto fail;
16363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16364 if (SWIG_arg_fail(1)) SWIG_fail;
16365 {
16366 PyThreadState* __tstate = wxPyBeginAllowThreads();
16367 result = (bool)((wxDC const *)arg1)->CanDrawBitmap();
16368
16369 wxPyEndAllowThreads(__tstate);
16370 if (PyErr_Occurred()) SWIG_fail;
16371 }
16372 {
16373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16374 }
16375 return resultobj;
16376 fail:
16377 return NULL;
16378 }
16379
16380
16381 static PyObject *_wrap_DC_CanGetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
16382 PyObject *resultobj;
16383 wxDC *arg1 = (wxDC *) 0 ;
16384 bool result;
16385 PyObject * obj0 = 0 ;
16386 char *kwnames[] = {
16387 (char *) "self", NULL
16388 };
16389
16390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanGetTextExtent",kwnames,&obj0)) goto fail;
16391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16392 if (SWIG_arg_fail(1)) SWIG_fail;
16393 {
16394 PyThreadState* __tstate = wxPyBeginAllowThreads();
16395 result = (bool)((wxDC const *)arg1)->CanGetTextExtent();
16396
16397 wxPyEndAllowThreads(__tstate);
16398 if (PyErr_Occurred()) SWIG_fail;
16399 }
16400 {
16401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16402 }
16403 return resultobj;
16404 fail:
16405 return NULL;
16406 }
16407
16408
16409 static PyObject *_wrap_DC_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
16410 PyObject *resultobj;
16411 wxDC *arg1 = (wxDC *) 0 ;
16412 int result;
16413 PyObject * obj0 = 0 ;
16414 char *kwnames[] = {
16415 (char *) "self", NULL
16416 };
16417
16418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDepth",kwnames,&obj0)) goto fail;
16419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16420 if (SWIG_arg_fail(1)) SWIG_fail;
16421 {
16422 PyThreadState* __tstate = wxPyBeginAllowThreads();
16423 result = (int)((wxDC const *)arg1)->GetDepth();
16424
16425 wxPyEndAllowThreads(__tstate);
16426 if (PyErr_Occurred()) SWIG_fail;
16427 }
16428 {
16429 resultobj = SWIG_From_int((int)(result));
16430 }
16431 return resultobj;
16432 fail:
16433 return NULL;
16434 }
16435
16436
16437 static PyObject *_wrap_DC_GetPPI(PyObject *, PyObject *args, PyObject *kwargs) {
16438 PyObject *resultobj;
16439 wxDC *arg1 = (wxDC *) 0 ;
16440 wxSize result;
16441 PyObject * obj0 = 0 ;
16442 char *kwnames[] = {
16443 (char *) "self", NULL
16444 };
16445
16446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPPI",kwnames,&obj0)) goto fail;
16447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16448 if (SWIG_arg_fail(1)) SWIG_fail;
16449 {
16450 PyThreadState* __tstate = wxPyBeginAllowThreads();
16451 result = ((wxDC const *)arg1)->GetPPI();
16452
16453 wxPyEndAllowThreads(__tstate);
16454 if (PyErr_Occurred()) SWIG_fail;
16455 }
16456 {
16457 wxSize * resultptr;
16458 resultptr = new wxSize((wxSize &)(result));
16459 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16460 }
16461 return resultobj;
16462 fail:
16463 return NULL;
16464 }
16465
16466
16467 static PyObject *_wrap_DC_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
16468 PyObject *resultobj;
16469 wxDC *arg1 = (wxDC *) 0 ;
16470 bool result;
16471 PyObject * obj0 = 0 ;
16472 char *kwnames[] = {
16473 (char *) "self", NULL
16474 };
16475
16476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Ok",kwnames,&obj0)) goto fail;
16477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16478 if (SWIG_arg_fail(1)) SWIG_fail;
16479 {
16480 PyThreadState* __tstate = wxPyBeginAllowThreads();
16481 result = (bool)((wxDC const *)arg1)->Ok();
16482
16483 wxPyEndAllowThreads(__tstate);
16484 if (PyErr_Occurred()) SWIG_fail;
16485 }
16486 {
16487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16488 }
16489 return resultobj;
16490 fail:
16491 return NULL;
16492 }
16493
16494
16495 static PyObject *_wrap_DC_GetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
16496 PyObject *resultobj;
16497 wxDC *arg1 = (wxDC *) 0 ;
16498 int result;
16499 PyObject * obj0 = 0 ;
16500 char *kwnames[] = {
16501 (char *) "self", NULL
16502 };
16503
16504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackgroundMode",kwnames,&obj0)) goto fail;
16505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16506 if (SWIG_arg_fail(1)) SWIG_fail;
16507 {
16508 PyThreadState* __tstate = wxPyBeginAllowThreads();
16509 result = (int)((wxDC const *)arg1)->GetBackgroundMode();
16510
16511 wxPyEndAllowThreads(__tstate);
16512 if (PyErr_Occurred()) SWIG_fail;
16513 }
16514 {
16515 resultobj = SWIG_From_int((int)(result));
16516 }
16517 return resultobj;
16518 fail:
16519 return NULL;
16520 }
16521
16522
16523 static PyObject *_wrap_DC_GetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16524 PyObject *resultobj;
16525 wxDC *arg1 = (wxDC *) 0 ;
16526 wxBrush *result;
16527 PyObject * obj0 = 0 ;
16528 char *kwnames[] = {
16529 (char *) "self", NULL
16530 };
16531
16532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackground",kwnames,&obj0)) goto fail;
16533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16534 if (SWIG_arg_fail(1)) SWIG_fail;
16535 {
16536 PyThreadState* __tstate = wxPyBeginAllowThreads();
16537 {
16538 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBackground();
16539 result = (wxBrush *) &_result_ref;
16540 }
16541
16542 wxPyEndAllowThreads(__tstate);
16543 if (PyErr_Occurred()) SWIG_fail;
16544 }
16545 {
16546 wxBrush* resultptr = new wxBrush(*result);
16547 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
16548 }
16549 return resultobj;
16550 fail:
16551 return NULL;
16552 }
16553
16554
16555 static PyObject *_wrap_DC_GetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
16556 PyObject *resultobj;
16557 wxDC *arg1 = (wxDC *) 0 ;
16558 wxBrush *result;
16559 PyObject * obj0 = 0 ;
16560 char *kwnames[] = {
16561 (char *) "self", NULL
16562 };
16563
16564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBrush",kwnames,&obj0)) goto fail;
16565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16566 if (SWIG_arg_fail(1)) SWIG_fail;
16567 {
16568 PyThreadState* __tstate = wxPyBeginAllowThreads();
16569 {
16570 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBrush();
16571 result = (wxBrush *) &_result_ref;
16572 }
16573
16574 wxPyEndAllowThreads(__tstate);
16575 if (PyErr_Occurred()) SWIG_fail;
16576 }
16577 {
16578 wxBrush* resultptr = new wxBrush(*result);
16579 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
16580 }
16581 return resultobj;
16582 fail:
16583 return NULL;
16584 }
16585
16586
16587 static PyObject *_wrap_DC_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
16588 PyObject *resultobj;
16589 wxDC *arg1 = (wxDC *) 0 ;
16590 wxFont *result;
16591 PyObject * obj0 = 0 ;
16592 char *kwnames[] = {
16593 (char *) "self", NULL
16594 };
16595
16596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetFont",kwnames,&obj0)) goto fail;
16597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16598 if (SWIG_arg_fail(1)) SWIG_fail;
16599 {
16600 PyThreadState* __tstate = wxPyBeginAllowThreads();
16601 {
16602 wxFont const &_result_ref = ((wxDC const *)arg1)->GetFont();
16603 result = (wxFont *) &_result_ref;
16604 }
16605
16606 wxPyEndAllowThreads(__tstate);
16607 if (PyErr_Occurred()) SWIG_fail;
16608 }
16609 {
16610 wxFont* resultptr = new wxFont(*result);
16611 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxFont, 1);
16612 }
16613 return resultobj;
16614 fail:
16615 return NULL;
16616 }
16617
16618
16619 static PyObject *_wrap_DC_GetPen(PyObject *, PyObject *args, PyObject *kwargs) {
16620 PyObject *resultobj;
16621 wxDC *arg1 = (wxDC *) 0 ;
16622 wxPen *result;
16623 PyObject * obj0 = 0 ;
16624 char *kwnames[] = {
16625 (char *) "self", NULL
16626 };
16627
16628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPen",kwnames,&obj0)) goto fail;
16629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16630 if (SWIG_arg_fail(1)) SWIG_fail;
16631 {
16632 PyThreadState* __tstate = wxPyBeginAllowThreads();
16633 {
16634 wxPen const &_result_ref = ((wxDC const *)arg1)->GetPen();
16635 result = (wxPen *) &_result_ref;
16636 }
16637
16638 wxPyEndAllowThreads(__tstate);
16639 if (PyErr_Occurred()) SWIG_fail;
16640 }
16641 {
16642 wxPen* resultptr = new wxPen(*result);
16643 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxPen, 1);
16644 }
16645 return resultobj;
16646 fail:
16647 return NULL;
16648 }
16649
16650
16651 static PyObject *_wrap_DC_GetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16652 PyObject *resultobj;
16653 wxDC *arg1 = (wxDC *) 0 ;
16654 wxColour *result;
16655 PyObject * obj0 = 0 ;
16656 char *kwnames[] = {
16657 (char *) "self", NULL
16658 };
16659
16660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextBackground",kwnames,&obj0)) goto fail;
16661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16662 if (SWIG_arg_fail(1)) SWIG_fail;
16663 {
16664 PyThreadState* __tstate = wxPyBeginAllowThreads();
16665 {
16666 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextBackground();
16667 result = (wxColour *) &_result_ref;
16668 }
16669
16670 wxPyEndAllowThreads(__tstate);
16671 if (PyErr_Occurred()) SWIG_fail;
16672 }
16673 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
16674 return resultobj;
16675 fail:
16676 return NULL;
16677 }
16678
16679
16680 static PyObject *_wrap_DC_GetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16681 PyObject *resultobj;
16682 wxDC *arg1 = (wxDC *) 0 ;
16683 wxColour *result;
16684 PyObject * obj0 = 0 ;
16685 char *kwnames[] = {
16686 (char *) "self", NULL
16687 };
16688
16689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextForeground",kwnames,&obj0)) goto fail;
16690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16691 if (SWIG_arg_fail(1)) SWIG_fail;
16692 {
16693 PyThreadState* __tstate = wxPyBeginAllowThreads();
16694 {
16695 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextForeground();
16696 result = (wxColour *) &_result_ref;
16697 }
16698
16699 wxPyEndAllowThreads(__tstate);
16700 if (PyErr_Occurred()) SWIG_fail;
16701 }
16702 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
16703 return resultobj;
16704 fail:
16705 return NULL;
16706 }
16707
16708
16709 static PyObject *_wrap_DC_SetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16710 PyObject *resultobj;
16711 wxDC *arg1 = (wxDC *) 0 ;
16712 wxColour *arg2 = 0 ;
16713 wxColour temp2 ;
16714 PyObject * obj0 = 0 ;
16715 PyObject * obj1 = 0 ;
16716 char *kwnames[] = {
16717 (char *) "self",(char *) "colour", NULL
16718 };
16719
16720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextForeground",kwnames,&obj0,&obj1)) goto fail;
16721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16722 if (SWIG_arg_fail(1)) SWIG_fail;
16723 {
16724 arg2 = &temp2;
16725 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16726 }
16727 {
16728 PyThreadState* __tstate = wxPyBeginAllowThreads();
16729 (arg1)->SetTextForeground((wxColour const &)*arg2);
16730
16731 wxPyEndAllowThreads(__tstate);
16732 if (PyErr_Occurred()) SWIG_fail;
16733 }
16734 Py_INCREF(Py_None); resultobj = Py_None;
16735 return resultobj;
16736 fail:
16737 return NULL;
16738 }
16739
16740
16741 static PyObject *_wrap_DC_SetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16742 PyObject *resultobj;
16743 wxDC *arg1 = (wxDC *) 0 ;
16744 wxColour *arg2 = 0 ;
16745 wxColour temp2 ;
16746 PyObject * obj0 = 0 ;
16747 PyObject * obj1 = 0 ;
16748 char *kwnames[] = {
16749 (char *) "self",(char *) "colour", NULL
16750 };
16751
16752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextBackground",kwnames,&obj0,&obj1)) goto fail;
16753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16754 if (SWIG_arg_fail(1)) SWIG_fail;
16755 {
16756 arg2 = &temp2;
16757 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16758 }
16759 {
16760 PyThreadState* __tstate = wxPyBeginAllowThreads();
16761 (arg1)->SetTextBackground((wxColour const &)*arg2);
16762
16763 wxPyEndAllowThreads(__tstate);
16764 if (PyErr_Occurred()) SWIG_fail;
16765 }
16766 Py_INCREF(Py_None); resultobj = Py_None;
16767 return resultobj;
16768 fail:
16769 return NULL;
16770 }
16771
16772
16773 static PyObject *_wrap_DC_GetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16774 PyObject *resultobj;
16775 wxDC *arg1 = (wxDC *) 0 ;
16776 int result;
16777 PyObject * obj0 = 0 ;
16778 char *kwnames[] = {
16779 (char *) "self", NULL
16780 };
16781
16782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetMapMode",kwnames,&obj0)) goto fail;
16783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16784 if (SWIG_arg_fail(1)) SWIG_fail;
16785 {
16786 PyThreadState* __tstate = wxPyBeginAllowThreads();
16787 result = (int)((wxDC const *)arg1)->GetMapMode();
16788
16789 wxPyEndAllowThreads(__tstate);
16790 if (PyErr_Occurred()) SWIG_fail;
16791 }
16792 {
16793 resultobj = SWIG_From_int((int)(result));
16794 }
16795 return resultobj;
16796 fail:
16797 return NULL;
16798 }
16799
16800
16801 static PyObject *_wrap_DC_SetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16802 PyObject *resultobj;
16803 wxDC *arg1 = (wxDC *) 0 ;
16804 int arg2 ;
16805 PyObject * obj0 = 0 ;
16806 PyObject * obj1 = 0 ;
16807 char *kwnames[] = {
16808 (char *) "self",(char *) "mode", NULL
16809 };
16810
16811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetMapMode",kwnames,&obj0,&obj1)) goto fail;
16812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16813 if (SWIG_arg_fail(1)) SWIG_fail;
16814 {
16815 arg2 = (int)(SWIG_As_int(obj1));
16816 if (SWIG_arg_fail(2)) SWIG_fail;
16817 }
16818 {
16819 PyThreadState* __tstate = wxPyBeginAllowThreads();
16820 (arg1)->SetMapMode(arg2);
16821
16822 wxPyEndAllowThreads(__tstate);
16823 if (PyErr_Occurred()) SWIG_fail;
16824 }
16825 Py_INCREF(Py_None); resultobj = Py_None;
16826 return resultobj;
16827 fail:
16828 return NULL;
16829 }
16830
16831
16832 static PyObject *_wrap_DC_GetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16833 PyObject *resultobj;
16834 wxDC *arg1 = (wxDC *) 0 ;
16835 double *arg2 = (double *) 0 ;
16836 double *arg3 = (double *) 0 ;
16837 double temp2 ;
16838 int res2 = 0 ;
16839 double temp3 ;
16840 int res3 = 0 ;
16841 PyObject * obj0 = 0 ;
16842 char *kwnames[] = {
16843 (char *) "self", NULL
16844 };
16845
16846 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16847 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetUserScale",kwnames,&obj0)) goto fail;
16849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16850 if (SWIG_arg_fail(1)) SWIG_fail;
16851 {
16852 PyThreadState* __tstate = wxPyBeginAllowThreads();
16853 ((wxDC const *)arg1)->GetUserScale(arg2,arg3);
16854
16855 wxPyEndAllowThreads(__tstate);
16856 if (PyErr_Occurred()) SWIG_fail;
16857 }
16858 Py_INCREF(Py_None); resultobj = Py_None;
16859 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16860 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16861 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16862 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16863 return resultobj;
16864 fail:
16865 return NULL;
16866 }
16867
16868
16869 static PyObject *_wrap_DC_SetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16870 PyObject *resultobj;
16871 wxDC *arg1 = (wxDC *) 0 ;
16872 double arg2 ;
16873 double arg3 ;
16874 PyObject * obj0 = 0 ;
16875 PyObject * obj1 = 0 ;
16876 PyObject * obj2 = 0 ;
16877 char *kwnames[] = {
16878 (char *) "self",(char *) "x",(char *) "y", NULL
16879 };
16880
16881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetUserScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16883 if (SWIG_arg_fail(1)) SWIG_fail;
16884 {
16885 arg2 = (double)(SWIG_As_double(obj1));
16886 if (SWIG_arg_fail(2)) SWIG_fail;
16887 }
16888 {
16889 arg3 = (double)(SWIG_As_double(obj2));
16890 if (SWIG_arg_fail(3)) SWIG_fail;
16891 }
16892 {
16893 PyThreadState* __tstate = wxPyBeginAllowThreads();
16894 (arg1)->SetUserScale(arg2,arg3);
16895
16896 wxPyEndAllowThreads(__tstate);
16897 if (PyErr_Occurred()) SWIG_fail;
16898 }
16899 Py_INCREF(Py_None); resultobj = Py_None;
16900 return resultobj;
16901 fail:
16902 return NULL;
16903 }
16904
16905
16906 static PyObject *_wrap_DC_GetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16907 PyObject *resultobj;
16908 wxDC *arg1 = (wxDC *) 0 ;
16909 double *arg2 = (double *) 0 ;
16910 double *arg3 = (double *) 0 ;
16911 double temp2 ;
16912 int res2 = 0 ;
16913 double temp3 ;
16914 int res3 = 0 ;
16915 PyObject * obj0 = 0 ;
16916 char *kwnames[] = {
16917 (char *) "self", NULL
16918 };
16919
16920 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16921 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalScale",kwnames,&obj0)) goto fail;
16923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16924 if (SWIG_arg_fail(1)) SWIG_fail;
16925 {
16926 PyThreadState* __tstate = wxPyBeginAllowThreads();
16927 (arg1)->GetLogicalScale(arg2,arg3);
16928
16929 wxPyEndAllowThreads(__tstate);
16930 if (PyErr_Occurred()) SWIG_fail;
16931 }
16932 Py_INCREF(Py_None); resultobj = Py_None;
16933 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16934 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16935 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16936 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16937 return resultobj;
16938 fail:
16939 return NULL;
16940 }
16941
16942
16943 static PyObject *_wrap_DC_SetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16944 PyObject *resultobj;
16945 wxDC *arg1 = (wxDC *) 0 ;
16946 double arg2 ;
16947 double arg3 ;
16948 PyObject * obj0 = 0 ;
16949 PyObject * obj1 = 0 ;
16950 PyObject * obj2 = 0 ;
16951 char *kwnames[] = {
16952 (char *) "self",(char *) "x",(char *) "y", NULL
16953 };
16954
16955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16957 if (SWIG_arg_fail(1)) SWIG_fail;
16958 {
16959 arg2 = (double)(SWIG_As_double(obj1));
16960 if (SWIG_arg_fail(2)) SWIG_fail;
16961 }
16962 {
16963 arg3 = (double)(SWIG_As_double(obj2));
16964 if (SWIG_arg_fail(3)) SWIG_fail;
16965 }
16966 {
16967 PyThreadState* __tstate = wxPyBeginAllowThreads();
16968 (arg1)->SetLogicalScale(arg2,arg3);
16969
16970 wxPyEndAllowThreads(__tstate);
16971 if (PyErr_Occurred()) SWIG_fail;
16972 }
16973 Py_INCREF(Py_None); resultobj = Py_None;
16974 return resultobj;
16975 fail:
16976 return NULL;
16977 }
16978
16979
16980 static PyObject *_wrap_DC_GetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16981 PyObject *resultobj;
16982 wxDC *arg1 = (wxDC *) 0 ;
16983 wxPoint result;
16984 PyObject * obj0 = 0 ;
16985 char *kwnames[] = {
16986 (char *) "self", NULL
16987 };
16988
16989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOrigin",kwnames,&obj0)) goto fail;
16990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16991 if (SWIG_arg_fail(1)) SWIG_fail;
16992 {
16993 PyThreadState* __tstate = wxPyBeginAllowThreads();
16994 result = ((wxDC const *)arg1)->GetLogicalOrigin();
16995
16996 wxPyEndAllowThreads(__tstate);
16997 if (PyErr_Occurred()) SWIG_fail;
16998 }
16999 {
17000 wxPoint * resultptr;
17001 resultptr = new wxPoint((wxPoint &)(result));
17002 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17003 }
17004 return resultobj;
17005 fail:
17006 return NULL;
17007 }
17008
17009
17010 static PyObject *_wrap_DC_GetLogicalOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17011 PyObject *resultobj;
17012 wxDC *arg1 = (wxDC *) 0 ;
17013 int *arg2 = (int *) 0 ;
17014 int *arg3 = (int *) 0 ;
17015 int temp2 ;
17016 int res2 = 0 ;
17017 int temp3 ;
17018 int res3 = 0 ;
17019 PyObject * obj0 = 0 ;
17020 char *kwnames[] = {
17021 (char *) "self", NULL
17022 };
17023
17024 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17025 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOriginTuple",kwnames,&obj0)) goto fail;
17027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17028 if (SWIG_arg_fail(1)) SWIG_fail;
17029 {
17030 PyThreadState* __tstate = wxPyBeginAllowThreads();
17031 ((wxDC const *)arg1)->GetLogicalOrigin(arg2,arg3);
17032
17033 wxPyEndAllowThreads(__tstate);
17034 if (PyErr_Occurred()) SWIG_fail;
17035 }
17036 Py_INCREF(Py_None); resultobj = Py_None;
17037 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17038 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
17039 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17040 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
17041 return resultobj;
17042 fail:
17043 return NULL;
17044 }
17045
17046
17047 static PyObject *_wrap_DC_SetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
17048 PyObject *resultobj;
17049 wxDC *arg1 = (wxDC *) 0 ;
17050 int arg2 ;
17051 int arg3 ;
17052 PyObject * obj0 = 0 ;
17053 PyObject * obj1 = 0 ;
17054 PyObject * obj2 = 0 ;
17055 char *kwnames[] = {
17056 (char *) "self",(char *) "x",(char *) "y", NULL
17057 };
17058
17059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
17060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17061 if (SWIG_arg_fail(1)) SWIG_fail;
17062 {
17063 arg2 = (int)(SWIG_As_int(obj1));
17064 if (SWIG_arg_fail(2)) SWIG_fail;
17065 }
17066 {
17067 arg3 = (int)(SWIG_As_int(obj2));
17068 if (SWIG_arg_fail(3)) SWIG_fail;
17069 }
17070 {
17071 PyThreadState* __tstate = wxPyBeginAllowThreads();
17072 (arg1)->SetLogicalOrigin(arg2,arg3);
17073
17074 wxPyEndAllowThreads(__tstate);
17075 if (PyErr_Occurred()) SWIG_fail;
17076 }
17077 Py_INCREF(Py_None); resultobj = Py_None;
17078 return resultobj;
17079 fail:
17080 return NULL;
17081 }
17082
17083
17084 static PyObject *_wrap_DC_SetLogicalOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
17085 PyObject *resultobj;
17086 wxDC *arg1 = (wxDC *) 0 ;
17087 wxPoint *arg2 = 0 ;
17088 wxPoint temp2 ;
17089 PyObject * obj0 = 0 ;
17090 PyObject * obj1 = 0 ;
17091 char *kwnames[] = {
17092 (char *) "self",(char *) "point", NULL
17093 };
17094
17095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalOriginPoint",kwnames,&obj0,&obj1)) goto fail;
17096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17097 if (SWIG_arg_fail(1)) SWIG_fail;
17098 {
17099 arg2 = &temp2;
17100 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17101 }
17102 {
17103 PyThreadState* __tstate = wxPyBeginAllowThreads();
17104 wxDC_SetLogicalOriginPoint(arg1,(wxPoint const &)*arg2);
17105
17106 wxPyEndAllowThreads(__tstate);
17107 if (PyErr_Occurred()) SWIG_fail;
17108 }
17109 Py_INCREF(Py_None); resultobj = Py_None;
17110 return resultobj;
17111 fail:
17112 return NULL;
17113 }
17114
17115
17116 static PyObject *_wrap_DC_GetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
17117 PyObject *resultobj;
17118 wxDC *arg1 = (wxDC *) 0 ;
17119 wxPoint result;
17120 PyObject * obj0 = 0 ;
17121 char *kwnames[] = {
17122 (char *) "self", NULL
17123 };
17124
17125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOrigin",kwnames,&obj0)) goto fail;
17126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17127 if (SWIG_arg_fail(1)) SWIG_fail;
17128 {
17129 PyThreadState* __tstate = wxPyBeginAllowThreads();
17130 result = ((wxDC const *)arg1)->GetDeviceOrigin();
17131
17132 wxPyEndAllowThreads(__tstate);
17133 if (PyErr_Occurred()) SWIG_fail;
17134 }
17135 {
17136 wxPoint * resultptr;
17137 resultptr = new wxPoint((wxPoint &)(result));
17138 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17139 }
17140 return resultobj;
17141 fail:
17142 return NULL;
17143 }
17144
17145
17146 static PyObject *_wrap_DC_GetDeviceOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17147 PyObject *resultobj;
17148 wxDC *arg1 = (wxDC *) 0 ;
17149 int *arg2 = (int *) 0 ;
17150 int *arg3 = (int *) 0 ;
17151 int temp2 ;
17152 int res2 = 0 ;
17153 int temp3 ;
17154 int res3 = 0 ;
17155 PyObject * obj0 = 0 ;
17156 char *kwnames[] = {
17157 (char *) "self", NULL
17158 };
17159
17160 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17161 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOriginTuple",kwnames,&obj0)) goto fail;
17163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17164 if (SWIG_arg_fail(1)) SWIG_fail;
17165 {
17166 PyThreadState* __tstate = wxPyBeginAllowThreads();
17167 ((wxDC const *)arg1)->GetDeviceOrigin(arg2,arg3);
17168
17169 wxPyEndAllowThreads(__tstate);
17170 if (PyErr_Occurred()) SWIG_fail;
17171 }
17172 Py_INCREF(Py_None); resultobj = Py_None;
17173 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17174 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
17175 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17176 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
17177 return resultobj;
17178 fail:
17179 return NULL;
17180 }
17181
17182
17183 static PyObject *_wrap_DC_SetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
17184 PyObject *resultobj;
17185 wxDC *arg1 = (wxDC *) 0 ;
17186 int arg2 ;
17187 int arg3 ;
17188 PyObject * obj0 = 0 ;
17189 PyObject * obj1 = 0 ;
17190 PyObject * obj2 = 0 ;
17191 char *kwnames[] = {
17192 (char *) "self",(char *) "x",(char *) "y", NULL
17193 };
17194
17195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetDeviceOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
17196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17197 if (SWIG_arg_fail(1)) SWIG_fail;
17198 {
17199 arg2 = (int)(SWIG_As_int(obj1));
17200 if (SWIG_arg_fail(2)) SWIG_fail;
17201 }
17202 {
17203 arg3 = (int)(SWIG_As_int(obj2));
17204 if (SWIG_arg_fail(3)) SWIG_fail;
17205 }
17206 {
17207 PyThreadState* __tstate = wxPyBeginAllowThreads();
17208 (arg1)->SetDeviceOrigin(arg2,arg3);
17209
17210 wxPyEndAllowThreads(__tstate);
17211 if (PyErr_Occurred()) SWIG_fail;
17212 }
17213 Py_INCREF(Py_None); resultobj = Py_None;
17214 return resultobj;
17215 fail:
17216 return NULL;
17217 }
17218
17219
17220 static PyObject *_wrap_DC_SetDeviceOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
17221 PyObject *resultobj;
17222 wxDC *arg1 = (wxDC *) 0 ;
17223 wxPoint *arg2 = 0 ;
17224 wxPoint temp2 ;
17225 PyObject * obj0 = 0 ;
17226 PyObject * obj1 = 0 ;
17227 char *kwnames[] = {
17228 (char *) "self",(char *) "point", NULL
17229 };
17230
17231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetDeviceOriginPoint",kwnames,&obj0,&obj1)) goto fail;
17232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17233 if (SWIG_arg_fail(1)) SWIG_fail;
17234 {
17235 arg2 = &temp2;
17236 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17237 }
17238 {
17239 PyThreadState* __tstate = wxPyBeginAllowThreads();
17240 wxDC_SetDeviceOriginPoint(arg1,(wxPoint const &)*arg2);
17241
17242 wxPyEndAllowThreads(__tstate);
17243 if (PyErr_Occurred()) SWIG_fail;
17244 }
17245 Py_INCREF(Py_None); resultobj = Py_None;
17246 return resultobj;
17247 fail:
17248 return NULL;
17249 }
17250
17251
17252 static PyObject *_wrap_DC_SetAxisOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
17253 PyObject *resultobj;
17254 wxDC *arg1 = (wxDC *) 0 ;
17255 bool arg2 ;
17256 bool arg3 ;
17257 PyObject * obj0 = 0 ;
17258 PyObject * obj1 = 0 ;
17259 PyObject * obj2 = 0 ;
17260 char *kwnames[] = {
17261 (char *) "self",(char *) "xLeftRight",(char *) "yBottomUp", NULL
17262 };
17263
17264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetAxisOrientation",kwnames,&obj0,&obj1,&obj2)) goto fail;
17265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17266 if (SWIG_arg_fail(1)) SWIG_fail;
17267 {
17268 arg2 = (bool)(SWIG_As_bool(obj1));
17269 if (SWIG_arg_fail(2)) SWIG_fail;
17270 }
17271 {
17272 arg3 = (bool)(SWIG_As_bool(obj2));
17273 if (SWIG_arg_fail(3)) SWIG_fail;
17274 }
17275 {
17276 PyThreadState* __tstate = wxPyBeginAllowThreads();
17277 (arg1)->SetAxisOrientation(arg2,arg3);
17278
17279 wxPyEndAllowThreads(__tstate);
17280 if (PyErr_Occurred()) SWIG_fail;
17281 }
17282 Py_INCREF(Py_None); resultobj = Py_None;
17283 return resultobj;
17284 fail:
17285 return NULL;
17286 }
17287
17288
17289 static PyObject *_wrap_DC_GetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
17290 PyObject *resultobj;
17291 wxDC *arg1 = (wxDC *) 0 ;
17292 int result;
17293 PyObject * obj0 = 0 ;
17294 char *kwnames[] = {
17295 (char *) "self", NULL
17296 };
17297
17298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalFunction",kwnames,&obj0)) goto fail;
17299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17300 if (SWIG_arg_fail(1)) SWIG_fail;
17301 {
17302 PyThreadState* __tstate = wxPyBeginAllowThreads();
17303 result = (int)((wxDC const *)arg1)->GetLogicalFunction();
17304
17305 wxPyEndAllowThreads(__tstate);
17306 if (PyErr_Occurred()) SWIG_fail;
17307 }
17308 {
17309 resultobj = SWIG_From_int((int)(result));
17310 }
17311 return resultobj;
17312 fail:
17313 return NULL;
17314 }
17315
17316
17317 static PyObject *_wrap_DC_SetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
17318 PyObject *resultobj;
17319 wxDC *arg1 = (wxDC *) 0 ;
17320 int arg2 ;
17321 PyObject * obj0 = 0 ;
17322 PyObject * obj1 = 0 ;
17323 char *kwnames[] = {
17324 (char *) "self",(char *) "function", NULL
17325 };
17326
17327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalFunction",kwnames,&obj0,&obj1)) goto fail;
17328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17329 if (SWIG_arg_fail(1)) SWIG_fail;
17330 {
17331 arg2 = (int)(SWIG_As_int(obj1));
17332 if (SWIG_arg_fail(2)) SWIG_fail;
17333 }
17334 {
17335 PyThreadState* __tstate = wxPyBeginAllowThreads();
17336 (arg1)->SetLogicalFunction(arg2);
17337
17338 wxPyEndAllowThreads(__tstate);
17339 if (PyErr_Occurred()) SWIG_fail;
17340 }
17341 Py_INCREF(Py_None); resultobj = Py_None;
17342 return resultobj;
17343 fail:
17344 return NULL;
17345 }
17346
17347
17348 static PyObject *_wrap_DC_ComputeScaleAndOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
17349 PyObject *resultobj;
17350 wxDC *arg1 = (wxDC *) 0 ;
17351 PyObject * obj0 = 0 ;
17352 char *kwnames[] = {
17353 (char *) "self", NULL
17354 };
17355
17356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ComputeScaleAndOrigin",kwnames,&obj0)) goto fail;
17357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17358 if (SWIG_arg_fail(1)) SWIG_fail;
17359 {
17360 PyThreadState* __tstate = wxPyBeginAllowThreads();
17361 (arg1)->ComputeScaleAndOrigin();
17362
17363 wxPyEndAllowThreads(__tstate);
17364 if (PyErr_Occurred()) SWIG_fail;
17365 }
17366 Py_INCREF(Py_None); resultobj = Py_None;
17367 return resultobj;
17368 fail:
17369 return NULL;
17370 }
17371
17372
17373 static PyObject *_wrap_DC_CalcBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
17374 PyObject *resultobj;
17375 wxDC *arg1 = (wxDC *) 0 ;
17376 int arg2 ;
17377 int arg3 ;
17378 PyObject * obj0 = 0 ;
17379 PyObject * obj1 = 0 ;
17380 PyObject * obj2 = 0 ;
17381 char *kwnames[] = {
17382 (char *) "self",(char *) "x",(char *) "y", NULL
17383 };
17384
17385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CalcBoundingBox",kwnames,&obj0,&obj1,&obj2)) goto fail;
17386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17387 if (SWIG_arg_fail(1)) SWIG_fail;
17388 {
17389 arg2 = (int)(SWIG_As_int(obj1));
17390 if (SWIG_arg_fail(2)) SWIG_fail;
17391 }
17392 {
17393 arg3 = (int)(SWIG_As_int(obj2));
17394 if (SWIG_arg_fail(3)) SWIG_fail;
17395 }
17396 {
17397 PyThreadState* __tstate = wxPyBeginAllowThreads();
17398 (arg1)->CalcBoundingBox(arg2,arg3);
17399
17400 wxPyEndAllowThreads(__tstate);
17401 if (PyErr_Occurred()) SWIG_fail;
17402 }
17403 Py_INCREF(Py_None); resultobj = Py_None;
17404 return resultobj;
17405 fail:
17406 return NULL;
17407 }
17408
17409
17410 static PyObject *_wrap_DC_CalcBoundingBoxPoint(PyObject *, PyObject *args, PyObject *kwargs) {
17411 PyObject *resultobj;
17412 wxDC *arg1 = (wxDC *) 0 ;
17413 wxPoint *arg2 = 0 ;
17414 wxPoint temp2 ;
17415 PyObject * obj0 = 0 ;
17416 PyObject * obj1 = 0 ;
17417 char *kwnames[] = {
17418 (char *) "self",(char *) "point", NULL
17419 };
17420
17421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CalcBoundingBoxPoint",kwnames,&obj0,&obj1)) goto fail;
17422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17423 if (SWIG_arg_fail(1)) SWIG_fail;
17424 {
17425 arg2 = &temp2;
17426 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17427 }
17428 {
17429 PyThreadState* __tstate = wxPyBeginAllowThreads();
17430 wxDC_CalcBoundingBoxPoint(arg1,(wxPoint const &)*arg2);
17431
17432 wxPyEndAllowThreads(__tstate);
17433 if (PyErr_Occurred()) SWIG_fail;
17434 }
17435 Py_INCREF(Py_None); resultobj = Py_None;
17436 return resultobj;
17437 fail:
17438 return NULL;
17439 }
17440
17441
17442 static PyObject *_wrap_DC_ResetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
17443 PyObject *resultobj;
17444 wxDC *arg1 = (wxDC *) 0 ;
17445 PyObject * obj0 = 0 ;
17446 char *kwnames[] = {
17447 (char *) "self", NULL
17448 };
17449
17450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ResetBoundingBox",kwnames,&obj0)) goto fail;
17451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17452 if (SWIG_arg_fail(1)) SWIG_fail;
17453 {
17454 PyThreadState* __tstate = wxPyBeginAllowThreads();
17455 (arg1)->ResetBoundingBox();
17456
17457 wxPyEndAllowThreads(__tstate);
17458 if (PyErr_Occurred()) SWIG_fail;
17459 }
17460 Py_INCREF(Py_None); resultobj = Py_None;
17461 return resultobj;
17462 fail:
17463 return NULL;
17464 }
17465
17466
17467 static PyObject *_wrap_DC_MinX(PyObject *, PyObject *args, PyObject *kwargs) {
17468 PyObject *resultobj;
17469 wxDC *arg1 = (wxDC *) 0 ;
17470 int result;
17471 PyObject * obj0 = 0 ;
17472 char *kwnames[] = {
17473 (char *) "self", NULL
17474 };
17475
17476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinX",kwnames,&obj0)) goto fail;
17477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17478 if (SWIG_arg_fail(1)) SWIG_fail;
17479 {
17480 PyThreadState* __tstate = wxPyBeginAllowThreads();
17481 result = (int)((wxDC const *)arg1)->MinX();
17482
17483 wxPyEndAllowThreads(__tstate);
17484 if (PyErr_Occurred()) SWIG_fail;
17485 }
17486 {
17487 resultobj = SWIG_From_int((int)(result));
17488 }
17489 return resultobj;
17490 fail:
17491 return NULL;
17492 }
17493
17494
17495 static PyObject *_wrap_DC_MaxX(PyObject *, PyObject *args, PyObject *kwargs) {
17496 PyObject *resultobj;
17497 wxDC *arg1 = (wxDC *) 0 ;
17498 int result;
17499 PyObject * obj0 = 0 ;
17500 char *kwnames[] = {
17501 (char *) "self", NULL
17502 };
17503
17504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxX",kwnames,&obj0)) goto fail;
17505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17506 if (SWIG_arg_fail(1)) SWIG_fail;
17507 {
17508 PyThreadState* __tstate = wxPyBeginAllowThreads();
17509 result = (int)((wxDC const *)arg1)->MaxX();
17510
17511 wxPyEndAllowThreads(__tstate);
17512 if (PyErr_Occurred()) SWIG_fail;
17513 }
17514 {
17515 resultobj = SWIG_From_int((int)(result));
17516 }
17517 return resultobj;
17518 fail:
17519 return NULL;
17520 }
17521
17522
17523 static PyObject *_wrap_DC_MinY(PyObject *, PyObject *args, PyObject *kwargs) {
17524 PyObject *resultobj;
17525 wxDC *arg1 = (wxDC *) 0 ;
17526 int result;
17527 PyObject * obj0 = 0 ;
17528 char *kwnames[] = {
17529 (char *) "self", NULL
17530 };
17531
17532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinY",kwnames,&obj0)) goto fail;
17533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17534 if (SWIG_arg_fail(1)) SWIG_fail;
17535 {
17536 PyThreadState* __tstate = wxPyBeginAllowThreads();
17537 result = (int)((wxDC const *)arg1)->MinY();
17538
17539 wxPyEndAllowThreads(__tstate);
17540 if (PyErr_Occurred()) SWIG_fail;
17541 }
17542 {
17543 resultobj = SWIG_From_int((int)(result));
17544 }
17545 return resultobj;
17546 fail:
17547 return NULL;
17548 }
17549
17550
17551 static PyObject *_wrap_DC_MaxY(PyObject *, PyObject *args, PyObject *kwargs) {
17552 PyObject *resultobj;
17553 wxDC *arg1 = (wxDC *) 0 ;
17554 int result;
17555 PyObject * obj0 = 0 ;
17556 char *kwnames[] = {
17557 (char *) "self", NULL
17558 };
17559
17560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxY",kwnames,&obj0)) goto fail;
17561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17562 if (SWIG_arg_fail(1)) SWIG_fail;
17563 {
17564 PyThreadState* __tstate = wxPyBeginAllowThreads();
17565 result = (int)((wxDC const *)arg1)->MaxY();
17566
17567 wxPyEndAllowThreads(__tstate);
17568 if (PyErr_Occurred()) SWIG_fail;
17569 }
17570 {
17571 resultobj = SWIG_From_int((int)(result));
17572 }
17573 return resultobj;
17574 fail:
17575 return NULL;
17576 }
17577
17578
17579 static PyObject *_wrap_DC_GetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
17580 PyObject *resultobj;
17581 wxDC *arg1 = (wxDC *) 0 ;
17582 int *arg2 = (int *) 0 ;
17583 int *arg3 = (int *) 0 ;
17584 int *arg4 = (int *) 0 ;
17585 int *arg5 = (int *) 0 ;
17586 int temp2 ;
17587 int res2 = 0 ;
17588 int temp3 ;
17589 int res3 = 0 ;
17590 int temp4 ;
17591 int res4 = 0 ;
17592 int temp5 ;
17593 int res5 = 0 ;
17594 PyObject * obj0 = 0 ;
17595 char *kwnames[] = {
17596 (char *) "self", NULL
17597 };
17598
17599 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17600 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17601 arg4 = &temp4; res4 = SWIG_NEWOBJ;
17602 arg5 = &temp5; res5 = SWIG_NEWOBJ;
17603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBoundingBox",kwnames,&obj0)) goto fail;
17604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17605 if (SWIG_arg_fail(1)) SWIG_fail;
17606 {
17607 PyThreadState* __tstate = wxPyBeginAllowThreads();
17608 wxDC_GetBoundingBox(arg1,arg2,arg3,arg4,arg5);
17609
17610 wxPyEndAllowThreads(__tstate);
17611 if (PyErr_Occurred()) SWIG_fail;
17612 }
17613 Py_INCREF(Py_None); resultobj = Py_None;
17614 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17615 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
17616 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17617 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
17618 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
17619 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
17620 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
17621 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
17622 return resultobj;
17623 fail:
17624 return NULL;
17625 }
17626
17627
17628 static PyObject *_wrap_DC_GetHDC(PyObject *, PyObject *args, PyObject *kwargs) {
17629 PyObject *resultobj;
17630 wxDC *arg1 = (wxDC *) 0 ;
17631 long result;
17632 PyObject * obj0 = 0 ;
17633 char *kwnames[] = {
17634 (char *) "self", NULL
17635 };
17636
17637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetHDC",kwnames,&obj0)) goto fail;
17638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17639 if (SWIG_arg_fail(1)) SWIG_fail;
17640 {
17641 PyThreadState* __tstate = wxPyBeginAllowThreads();
17642 result = (long)(arg1)->GetHDC();
17643
17644 wxPyEndAllowThreads(__tstate);
17645 if (PyErr_Occurred()) SWIG_fail;
17646 }
17647 {
17648 resultobj = SWIG_From_long((long)(result));
17649 }
17650 return resultobj;
17651 fail:
17652 return NULL;
17653 }
17654
17655
17656 static PyObject *_wrap_DC__DrawPointList(PyObject *, PyObject *args, PyObject *kwargs) {
17657 PyObject *resultobj;
17658 wxDC *arg1 = (wxDC *) 0 ;
17659 PyObject *arg2 = (PyObject *) 0 ;
17660 PyObject *arg3 = (PyObject *) 0 ;
17661 PyObject *arg4 = (PyObject *) 0 ;
17662 PyObject *result;
17663 PyObject * obj0 = 0 ;
17664 PyObject * obj1 = 0 ;
17665 PyObject * obj2 = 0 ;
17666 PyObject * obj3 = 0 ;
17667 char *kwnames[] = {
17668 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17669 };
17670
17671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPointList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17673 if (SWIG_arg_fail(1)) SWIG_fail;
17674 arg2 = obj1;
17675 arg3 = obj2;
17676 arg4 = obj3;
17677 {
17678 PyThreadState* __tstate = wxPyBeginAllowThreads();
17679 result = (PyObject *)wxDC__DrawPointList(arg1,arg2,arg3,arg4);
17680
17681 wxPyEndAllowThreads(__tstate);
17682 if (PyErr_Occurred()) SWIG_fail;
17683 }
17684 resultobj = result;
17685 return resultobj;
17686 fail:
17687 return NULL;
17688 }
17689
17690
17691 static PyObject *_wrap_DC__DrawLineList(PyObject *, PyObject *args, PyObject *kwargs) {
17692 PyObject *resultobj;
17693 wxDC *arg1 = (wxDC *) 0 ;
17694 PyObject *arg2 = (PyObject *) 0 ;
17695 PyObject *arg3 = (PyObject *) 0 ;
17696 PyObject *arg4 = (PyObject *) 0 ;
17697 PyObject *result;
17698 PyObject * obj0 = 0 ;
17699 PyObject * obj1 = 0 ;
17700 PyObject * obj2 = 0 ;
17701 PyObject * obj3 = 0 ;
17702 char *kwnames[] = {
17703 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17704 };
17705
17706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawLineList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17708 if (SWIG_arg_fail(1)) SWIG_fail;
17709 arg2 = obj1;
17710 arg3 = obj2;
17711 arg4 = obj3;
17712 {
17713 PyThreadState* __tstate = wxPyBeginAllowThreads();
17714 result = (PyObject *)wxDC__DrawLineList(arg1,arg2,arg3,arg4);
17715
17716 wxPyEndAllowThreads(__tstate);
17717 if (PyErr_Occurred()) SWIG_fail;
17718 }
17719 resultobj = result;
17720 return resultobj;
17721 fail:
17722 return NULL;
17723 }
17724
17725
17726 static PyObject *_wrap_DC__DrawRectangleList(PyObject *, PyObject *args, PyObject *kwargs) {
17727 PyObject *resultobj;
17728 wxDC *arg1 = (wxDC *) 0 ;
17729 PyObject *arg2 = (PyObject *) 0 ;
17730 PyObject *arg3 = (PyObject *) 0 ;
17731 PyObject *arg4 = (PyObject *) 0 ;
17732 PyObject *result;
17733 PyObject * obj0 = 0 ;
17734 PyObject * obj1 = 0 ;
17735 PyObject * obj2 = 0 ;
17736 PyObject * obj3 = 0 ;
17737 char *kwnames[] = {
17738 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17739 };
17740
17741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawRectangleList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17743 if (SWIG_arg_fail(1)) SWIG_fail;
17744 arg2 = obj1;
17745 arg3 = obj2;
17746 arg4 = obj3;
17747 {
17748 PyThreadState* __tstate = wxPyBeginAllowThreads();
17749 result = (PyObject *)wxDC__DrawRectangleList(arg1,arg2,arg3,arg4);
17750
17751 wxPyEndAllowThreads(__tstate);
17752 if (PyErr_Occurred()) SWIG_fail;
17753 }
17754 resultobj = result;
17755 return resultobj;
17756 fail:
17757 return NULL;
17758 }
17759
17760
17761 static PyObject *_wrap_DC__DrawEllipseList(PyObject *, PyObject *args, PyObject *kwargs) {
17762 PyObject *resultobj;
17763 wxDC *arg1 = (wxDC *) 0 ;
17764 PyObject *arg2 = (PyObject *) 0 ;
17765 PyObject *arg3 = (PyObject *) 0 ;
17766 PyObject *arg4 = (PyObject *) 0 ;
17767 PyObject *result;
17768 PyObject * obj0 = 0 ;
17769 PyObject * obj1 = 0 ;
17770 PyObject * obj2 = 0 ;
17771 PyObject * obj3 = 0 ;
17772 char *kwnames[] = {
17773 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17774 };
17775
17776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawEllipseList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17778 if (SWIG_arg_fail(1)) SWIG_fail;
17779 arg2 = obj1;
17780 arg3 = obj2;
17781 arg4 = obj3;
17782 {
17783 PyThreadState* __tstate = wxPyBeginAllowThreads();
17784 result = (PyObject *)wxDC__DrawEllipseList(arg1,arg2,arg3,arg4);
17785
17786 wxPyEndAllowThreads(__tstate);
17787 if (PyErr_Occurred()) SWIG_fail;
17788 }
17789 resultobj = result;
17790 return resultobj;
17791 fail:
17792 return NULL;
17793 }
17794
17795
17796 static PyObject *_wrap_DC__DrawPolygonList(PyObject *, PyObject *args, PyObject *kwargs) {
17797 PyObject *resultobj;
17798 wxDC *arg1 = (wxDC *) 0 ;
17799 PyObject *arg2 = (PyObject *) 0 ;
17800 PyObject *arg3 = (PyObject *) 0 ;
17801 PyObject *arg4 = (PyObject *) 0 ;
17802 PyObject *result;
17803 PyObject * obj0 = 0 ;
17804 PyObject * obj1 = 0 ;
17805 PyObject * obj2 = 0 ;
17806 PyObject * obj3 = 0 ;
17807 char *kwnames[] = {
17808 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17809 };
17810
17811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPolygonList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17813 if (SWIG_arg_fail(1)) SWIG_fail;
17814 arg2 = obj1;
17815 arg3 = obj2;
17816 arg4 = obj3;
17817 {
17818 PyThreadState* __tstate = wxPyBeginAllowThreads();
17819 result = (PyObject *)wxDC__DrawPolygonList(arg1,arg2,arg3,arg4);
17820
17821 wxPyEndAllowThreads(__tstate);
17822 if (PyErr_Occurred()) SWIG_fail;
17823 }
17824 resultobj = result;
17825 return resultobj;
17826 fail:
17827 return NULL;
17828 }
17829
17830
17831 static PyObject *_wrap_DC__DrawTextList(PyObject *, PyObject *args, PyObject *kwargs) {
17832 PyObject *resultobj;
17833 wxDC *arg1 = (wxDC *) 0 ;
17834 PyObject *arg2 = (PyObject *) 0 ;
17835 PyObject *arg3 = (PyObject *) 0 ;
17836 PyObject *arg4 = (PyObject *) 0 ;
17837 PyObject *arg5 = (PyObject *) 0 ;
17838 PyObject *result;
17839 PyObject * obj0 = 0 ;
17840 PyObject * obj1 = 0 ;
17841 PyObject * obj2 = 0 ;
17842 PyObject * obj3 = 0 ;
17843 PyObject * obj4 = 0 ;
17844 char *kwnames[] = {
17845 (char *) "self",(char *) "textList",(char *) "pyPoints",(char *) "foregroundList",(char *) "backgroundList", NULL
17846 };
17847
17848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC__DrawTextList",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
17849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17850 if (SWIG_arg_fail(1)) SWIG_fail;
17851 arg2 = obj1;
17852 arg3 = obj2;
17853 arg4 = obj3;
17854 arg5 = obj4;
17855 {
17856 PyThreadState* __tstate = wxPyBeginAllowThreads();
17857 result = (PyObject *)wxDC__DrawTextList(arg1,arg2,arg3,arg4,arg5);
17858
17859 wxPyEndAllowThreads(__tstate);
17860 if (PyErr_Occurred()) SWIG_fail;
17861 }
17862 resultobj = result;
17863 return resultobj;
17864 fail:
17865 return NULL;
17866 }
17867
17868
17869 static PyObject * DC_swigregister(PyObject *, PyObject *args) {
17870 PyObject *obj;
17871 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17872 SWIG_TypeClientData(SWIGTYPE_p_wxDC, obj);
17873 Py_INCREF(obj);
17874 return Py_BuildValue((char *)"");
17875 }
17876 static PyObject *_wrap_new_MemoryDC(PyObject *, PyObject *args, PyObject *kwargs) {
17877 PyObject *resultobj;
17878 wxMemoryDC *result;
17879 char *kwnames[] = {
17880 NULL
17881 };
17882
17883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryDC",kwnames)) goto fail;
17884 {
17885 if (!wxPyCheckForApp()) SWIG_fail;
17886 PyThreadState* __tstate = wxPyBeginAllowThreads();
17887 result = (wxMemoryDC *)new wxMemoryDC();
17888
17889 wxPyEndAllowThreads(__tstate);
17890 if (PyErr_Occurred()) SWIG_fail;
17891 }
17892 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17893 return resultobj;
17894 fail:
17895 return NULL;
17896 }
17897
17898
17899 static PyObject *_wrap_new_MemoryDCFromDC(PyObject *, PyObject *args, PyObject *kwargs) {
17900 PyObject *resultobj;
17901 wxDC *arg1 = (wxDC *) 0 ;
17902 wxMemoryDC *result;
17903 PyObject * obj0 = 0 ;
17904 char *kwnames[] = {
17905 (char *) "oldDC", NULL
17906 };
17907
17908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_MemoryDCFromDC",kwnames,&obj0)) goto fail;
17909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17910 if (SWIG_arg_fail(1)) SWIG_fail;
17911 {
17912 if (!wxPyCheckForApp()) SWIG_fail;
17913 PyThreadState* __tstate = wxPyBeginAllowThreads();
17914 result = (wxMemoryDC *)new wxMemoryDC(arg1);
17915
17916 wxPyEndAllowThreads(__tstate);
17917 if (PyErr_Occurred()) SWIG_fail;
17918 }
17919 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17920 return resultobj;
17921 fail:
17922 return NULL;
17923 }
17924
17925
17926 static PyObject *_wrap_MemoryDC_SelectObject(PyObject *, PyObject *args, PyObject *kwargs) {
17927 PyObject *resultobj;
17928 wxMemoryDC *arg1 = (wxMemoryDC *) 0 ;
17929 wxBitmap *arg2 = 0 ;
17930 PyObject * obj0 = 0 ;
17931 PyObject * obj1 = 0 ;
17932 char *kwnames[] = {
17933 (char *) "self",(char *) "bitmap", NULL
17934 };
17935
17936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryDC_SelectObject",kwnames,&obj0,&obj1)) goto fail;
17937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_EXCEPTION | 0);
17938 if (SWIG_arg_fail(1)) SWIG_fail;
17939 {
17940 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17941 if (SWIG_arg_fail(2)) SWIG_fail;
17942 if (arg2 == NULL) {
17943 SWIG_null_ref("wxBitmap");
17944 }
17945 if (SWIG_arg_fail(2)) SWIG_fail;
17946 }
17947 {
17948 PyThreadState* __tstate = wxPyBeginAllowThreads();
17949 (arg1)->SelectObject((wxBitmap const &)*arg2);
17950
17951 wxPyEndAllowThreads(__tstate);
17952 if (PyErr_Occurred()) SWIG_fail;
17953 }
17954 Py_INCREF(Py_None); resultobj = Py_None;
17955 return resultobj;
17956 fail:
17957 return NULL;
17958 }
17959
17960
17961 static PyObject * MemoryDC_swigregister(PyObject *, PyObject *args) {
17962 PyObject *obj;
17963 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17964 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryDC, obj);
17965 Py_INCREF(obj);
17966 return Py_BuildValue((char *)"");
17967 }
17968 static PyObject *_wrap_new_BufferedDC__SWIG_0(PyObject *, PyObject *args) {
17969 PyObject *resultobj;
17970 wxDC *arg1 = (wxDC *) 0 ;
17971 wxBitmap const &arg2_defvalue = wxNullBitmap ;
17972 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
17973 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17974 wxBufferedDC *result;
17975 PyObject * obj0 = 0 ;
17976 PyObject * obj1 = 0 ;
17977 PyObject * obj2 = 0 ;
17978
17979 if(!PyArg_ParseTuple(args,(char *)"O|OO:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
17980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17981 if (SWIG_arg_fail(1)) SWIG_fail;
17982 if (obj1) {
17983 {
17984 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17985 if (SWIG_arg_fail(2)) SWIG_fail;
17986 if (arg2 == NULL) {
17987 SWIG_null_ref("wxBitmap");
17988 }
17989 if (SWIG_arg_fail(2)) SWIG_fail;
17990 }
17991 }
17992 if (obj2) {
17993 {
17994 arg3 = (int)(SWIG_As_int(obj2));
17995 if (SWIG_arg_fail(3)) SWIG_fail;
17996 }
17997 }
17998 {
17999 if (!wxPyCheckForApp()) SWIG_fail;
18000 PyThreadState* __tstate = wxPyBeginAllowThreads();
18001 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxBitmap const &)*arg2,arg3);
18002
18003 wxPyEndAllowThreads(__tstate);
18004 if (PyErr_Occurred()) SWIG_fail;
18005 }
18006 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
18007 return resultobj;
18008 fail:
18009 return NULL;
18010 }
18011
18012
18013 static PyObject *_wrap_new_BufferedDC__SWIG_1(PyObject *, PyObject *args) {
18014 PyObject *resultobj;
18015 wxDC *arg1 = (wxDC *) 0 ;
18016 wxSize *arg2 = 0 ;
18017 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
18018 wxBufferedDC *result;
18019 wxSize temp2 ;
18020 PyObject * obj0 = 0 ;
18021 PyObject * obj1 = 0 ;
18022 PyObject * obj2 = 0 ;
18023
18024 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
18025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18026 if (SWIG_arg_fail(1)) SWIG_fail;
18027 {
18028 arg2 = &temp2;
18029 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
18030 }
18031 if (obj2) {
18032 {
18033 arg3 = (int)(SWIG_As_int(obj2));
18034 if (SWIG_arg_fail(3)) SWIG_fail;
18035 }
18036 }
18037 {
18038 if (!wxPyCheckForApp()) SWIG_fail;
18039 PyThreadState* __tstate = wxPyBeginAllowThreads();
18040 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxSize const &)*arg2,arg3);
18041
18042 wxPyEndAllowThreads(__tstate);
18043 if (PyErr_Occurred()) SWIG_fail;
18044 }
18045 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
18046 return resultobj;
18047 fail:
18048 return NULL;
18049 }
18050
18051
18052 static PyObject *_wrap_new_BufferedDC(PyObject *self, PyObject *args) {
18053 int argc;
18054 PyObject *argv[4];
18055 int ii;
18056
18057 argc = PyObject_Length(args);
18058 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
18059 argv[ii] = PyTuple_GetItem(args,ii);
18060 }
18061 if ((argc >= 1) && (argc <= 3)) {
18062 int _v;
18063 {
18064 void *ptr;
18065 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
18066 _v = 0;
18067 PyErr_Clear();
18068 } else {
18069 _v = 1;
18070 }
18071 }
18072 if (_v) {
18073 if (argc <= 1) {
18074 return _wrap_new_BufferedDC__SWIG_0(self,args);
18075 }
18076 {
18077 void *ptr = 0;
18078 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxBitmap, 0) == -1) {
18079 _v = 0;
18080 PyErr_Clear();
18081 } else {
18082 _v = (ptr != 0);
18083 }
18084 }
18085 if (_v) {
18086 if (argc <= 2) {
18087 return _wrap_new_BufferedDC__SWIG_0(self,args);
18088 }
18089 _v = SWIG_Check_int(argv[2]);
18090 if (_v) {
18091 return _wrap_new_BufferedDC__SWIG_0(self,args);
18092 }
18093 }
18094 }
18095 }
18096 if ((argc >= 2) && (argc <= 3)) {
18097 int _v;
18098 {
18099 void *ptr;
18100 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
18101 _v = 0;
18102 PyErr_Clear();
18103 } else {
18104 _v = 1;
18105 }
18106 }
18107 if (_v) {
18108 {
18109 _v = wxPySimple_typecheck(argv[1], wxT("wxSize"), 2);
18110 }
18111 if (_v) {
18112 if (argc <= 2) {
18113 return _wrap_new_BufferedDC__SWIG_1(self,args);
18114 }
18115 _v = SWIG_Check_int(argv[2]);
18116 if (_v) {
18117 return _wrap_new_BufferedDC__SWIG_1(self,args);
18118 }
18119 }
18120 }
18121 }
18122
18123 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_BufferedDC'");
18124 return NULL;
18125 }
18126
18127
18128 static PyObject *_wrap_delete_BufferedDC(PyObject *, PyObject *args, PyObject *kwargs) {
18129 PyObject *resultobj;
18130 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
18131 PyObject * obj0 = 0 ;
18132 char *kwnames[] = {
18133 (char *) "self", NULL
18134 };
18135
18136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BufferedDC",kwnames,&obj0)) goto fail;
18137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
18138 if (SWIG_arg_fail(1)) SWIG_fail;
18139 {
18140 PyThreadState* __tstate = wxPyBeginAllowThreads();
18141 delete arg1;
18142
18143 wxPyEndAllowThreads(__tstate);
18144 if (PyErr_Occurred()) SWIG_fail;
18145 }
18146 Py_INCREF(Py_None); resultobj = Py_None;
18147 return resultobj;
18148 fail:
18149 return NULL;
18150 }
18151
18152
18153 static PyObject *_wrap_BufferedDC_UnMask(PyObject *, PyObject *args, PyObject *kwargs) {
18154 PyObject *resultobj;
18155 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
18156 PyObject * obj0 = 0 ;
18157 char *kwnames[] = {
18158 (char *) "self", NULL
18159 };
18160
18161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BufferedDC_UnMask",kwnames,&obj0)) goto fail;
18162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
18163 if (SWIG_arg_fail(1)) SWIG_fail;
18164 {
18165 PyThreadState* __tstate = wxPyBeginAllowThreads();
18166 (arg1)->UnMask();
18167
18168 wxPyEndAllowThreads(__tstate);
18169 if (PyErr_Occurred()) SWIG_fail;
18170 }
18171 Py_INCREF(Py_None); resultobj = Py_None;
18172 return resultobj;
18173 fail:
18174 return NULL;
18175 }
18176
18177
18178 static PyObject * BufferedDC_swigregister(PyObject *, PyObject *args) {
18179 PyObject *obj;
18180 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18181 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedDC, obj);
18182 Py_INCREF(obj);
18183 return Py_BuildValue((char *)"");
18184 }
18185 static PyObject *_wrap_new_BufferedPaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
18186 PyObject *resultobj;
18187 wxWindow *arg1 = (wxWindow *) 0 ;
18188 wxBitmap const &arg2_defvalue = wxNullBitmap ;
18189 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
18190 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
18191 wxBufferedPaintDC *result;
18192 PyObject * obj0 = 0 ;
18193 PyObject * obj1 = 0 ;
18194 PyObject * obj2 = 0 ;
18195 char *kwnames[] = {
18196 (char *) "window",(char *) "buffer",(char *) "style", NULL
18197 };
18198
18199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_BufferedPaintDC",kwnames,&obj0,&obj1,&obj2)) goto fail;
18200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18201 if (SWIG_arg_fail(1)) SWIG_fail;
18202 if (obj1) {
18203 {
18204 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18205 if (SWIG_arg_fail(2)) SWIG_fail;
18206 if (arg2 == NULL) {
18207 SWIG_null_ref("wxBitmap");
18208 }
18209 if (SWIG_arg_fail(2)) SWIG_fail;
18210 }
18211 }
18212 if (obj2) {
18213 {
18214 arg3 = (int)(SWIG_As_int(obj2));
18215 if (SWIG_arg_fail(3)) SWIG_fail;
18216 }
18217 }
18218 {
18219 if (!wxPyCheckForApp()) SWIG_fail;
18220 PyThreadState* __tstate = wxPyBeginAllowThreads();
18221 result = (wxBufferedPaintDC *)new wxBufferedPaintDC(arg1,(wxBitmap const &)*arg2,arg3);
18222
18223 wxPyEndAllowThreads(__tstate);
18224 if (PyErr_Occurred()) SWIG_fail;
18225 }
18226 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedPaintDC, 1);
18227 return resultobj;
18228 fail:
18229 return NULL;
18230 }
18231
18232
18233 static PyObject * BufferedPaintDC_swigregister(PyObject *, PyObject *args) {
18234 PyObject *obj;
18235 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18236 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedPaintDC, obj);
18237 Py_INCREF(obj);
18238 return Py_BuildValue((char *)"");
18239 }
18240 static PyObject *_wrap_new_ScreenDC(PyObject *, PyObject *args, PyObject *kwargs) {
18241 PyObject *resultobj;
18242 wxScreenDC *result;
18243 char *kwnames[] = {
18244 NULL
18245 };
18246
18247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ScreenDC",kwnames)) goto fail;
18248 {
18249 if (!wxPyCheckForApp()) SWIG_fail;
18250 PyThreadState* __tstate = wxPyBeginAllowThreads();
18251 result = (wxScreenDC *)new wxScreenDC();
18252
18253 wxPyEndAllowThreads(__tstate);
18254 if (PyErr_Occurred()) SWIG_fail;
18255 }
18256 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScreenDC, 1);
18257 return resultobj;
18258 fail:
18259 return NULL;
18260 }
18261
18262
18263 static PyObject *_wrap_ScreenDC_StartDrawingOnTopWin(PyObject *, PyObject *args, PyObject *kwargs) {
18264 PyObject *resultobj;
18265 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
18266 wxWindow *arg2 = (wxWindow *) 0 ;
18267 bool result;
18268 PyObject * obj0 = 0 ;
18269 PyObject * obj1 = 0 ;
18270 char *kwnames[] = {
18271 (char *) "self",(char *) "window", NULL
18272 };
18273
18274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScreenDC_StartDrawingOnTopWin",kwnames,&obj0,&obj1)) goto fail;
18275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
18276 if (SWIG_arg_fail(1)) SWIG_fail;
18277 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18278 if (SWIG_arg_fail(2)) SWIG_fail;
18279 {
18280 PyThreadState* __tstate = wxPyBeginAllowThreads();
18281 result = (bool)(arg1)->StartDrawingOnTop(arg2);
18282
18283 wxPyEndAllowThreads(__tstate);
18284 if (PyErr_Occurred()) SWIG_fail;
18285 }
18286 {
18287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18288 }
18289 return resultobj;
18290 fail:
18291 return NULL;
18292 }
18293
18294
18295 static PyObject *_wrap_ScreenDC_StartDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
18296 PyObject *resultobj;
18297 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
18298 wxRect *arg2 = (wxRect *) NULL ;
18299 bool result;
18300 PyObject * obj0 = 0 ;
18301 PyObject * obj1 = 0 ;
18302 char *kwnames[] = {
18303 (char *) "self",(char *) "rect", NULL
18304 };
18305
18306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ScreenDC_StartDrawingOnTop",kwnames,&obj0,&obj1)) goto fail;
18307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
18308 if (SWIG_arg_fail(1)) SWIG_fail;
18309 if (obj1) {
18310 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
18311 if (SWIG_arg_fail(2)) SWIG_fail;
18312 }
18313 {
18314 PyThreadState* __tstate = wxPyBeginAllowThreads();
18315 result = (bool)(arg1)->StartDrawingOnTop(arg2);
18316
18317 wxPyEndAllowThreads(__tstate);
18318 if (PyErr_Occurred()) SWIG_fail;
18319 }
18320 {
18321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18322 }
18323 return resultobj;
18324 fail:
18325 return NULL;
18326 }
18327
18328
18329 static PyObject *_wrap_ScreenDC_EndDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
18330 PyObject *resultobj;
18331 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
18332 bool result;
18333 PyObject * obj0 = 0 ;
18334 char *kwnames[] = {
18335 (char *) "self", NULL
18336 };
18337
18338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScreenDC_EndDrawingOnTop",kwnames,&obj0)) goto fail;
18339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
18340 if (SWIG_arg_fail(1)) SWIG_fail;
18341 {
18342 PyThreadState* __tstate = wxPyBeginAllowThreads();
18343 result = (bool)(arg1)->EndDrawingOnTop();
18344
18345 wxPyEndAllowThreads(__tstate);
18346 if (PyErr_Occurred()) SWIG_fail;
18347 }
18348 {
18349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18350 }
18351 return resultobj;
18352 fail:
18353 return NULL;
18354 }
18355
18356
18357 static PyObject * ScreenDC_swigregister(PyObject *, PyObject *args) {
18358 PyObject *obj;
18359 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18360 SWIG_TypeClientData(SWIGTYPE_p_wxScreenDC, obj);
18361 Py_INCREF(obj);
18362 return Py_BuildValue((char *)"");
18363 }
18364 static PyObject *_wrap_new_ClientDC(PyObject *, PyObject *args, PyObject *kwargs) {
18365 PyObject *resultobj;
18366 wxWindow *arg1 = (wxWindow *) 0 ;
18367 wxClientDC *result;
18368 PyObject * obj0 = 0 ;
18369 char *kwnames[] = {
18370 (char *) "win", NULL
18371 };
18372
18373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ClientDC",kwnames,&obj0)) goto fail;
18374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18375 if (SWIG_arg_fail(1)) SWIG_fail;
18376 {
18377 if (!wxPyCheckForApp()) SWIG_fail;
18378 PyThreadState* __tstate = wxPyBeginAllowThreads();
18379 result = (wxClientDC *)new wxClientDC(arg1);
18380
18381 wxPyEndAllowThreads(__tstate);
18382 if (PyErr_Occurred()) SWIG_fail;
18383 }
18384 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClientDC, 1);
18385 return resultobj;
18386 fail:
18387 return NULL;
18388 }
18389
18390
18391 static PyObject * ClientDC_swigregister(PyObject *, PyObject *args) {
18392 PyObject *obj;
18393 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18394 SWIG_TypeClientData(SWIGTYPE_p_wxClientDC, obj);
18395 Py_INCREF(obj);
18396 return Py_BuildValue((char *)"");
18397 }
18398 static PyObject *_wrap_new_PaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
18399 PyObject *resultobj;
18400 wxWindow *arg1 = (wxWindow *) 0 ;
18401 wxPaintDC *result;
18402 PyObject * obj0 = 0 ;
18403 char *kwnames[] = {
18404 (char *) "win", NULL
18405 };
18406
18407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PaintDC",kwnames,&obj0)) goto fail;
18408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18409 if (SWIG_arg_fail(1)) SWIG_fail;
18410 {
18411 if (!wxPyCheckForApp()) SWIG_fail;
18412 PyThreadState* __tstate = wxPyBeginAllowThreads();
18413 result = (wxPaintDC *)new wxPaintDC(arg1);
18414
18415 wxPyEndAllowThreads(__tstate);
18416 if (PyErr_Occurred()) SWIG_fail;
18417 }
18418 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintDC, 1);
18419 return resultobj;
18420 fail:
18421 return NULL;
18422 }
18423
18424
18425 static PyObject * PaintDC_swigregister(PyObject *, PyObject *args) {
18426 PyObject *obj;
18427 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18428 SWIG_TypeClientData(SWIGTYPE_p_wxPaintDC, obj);
18429 Py_INCREF(obj);
18430 return Py_BuildValue((char *)"");
18431 }
18432 static PyObject *_wrap_new_WindowDC(PyObject *, PyObject *args, PyObject *kwargs) {
18433 PyObject *resultobj;
18434 wxWindow *arg1 = (wxWindow *) 0 ;
18435 wxWindowDC *result;
18436 PyObject * obj0 = 0 ;
18437 char *kwnames[] = {
18438 (char *) "win", NULL
18439 };
18440
18441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_WindowDC",kwnames,&obj0)) goto fail;
18442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18443 if (SWIG_arg_fail(1)) SWIG_fail;
18444 {
18445 if (!wxPyCheckForApp()) SWIG_fail;
18446 PyThreadState* __tstate = wxPyBeginAllowThreads();
18447 result = (wxWindowDC *)new wxWindowDC(arg1);
18448
18449 wxPyEndAllowThreads(__tstate);
18450 if (PyErr_Occurred()) SWIG_fail;
18451 }
18452 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDC, 1);
18453 return resultobj;
18454 fail:
18455 return NULL;
18456 }
18457
18458
18459 static PyObject * WindowDC_swigregister(PyObject *, PyObject *args) {
18460 PyObject *obj;
18461 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18462 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDC, obj);
18463 Py_INCREF(obj);
18464 return Py_BuildValue((char *)"");
18465 }
18466 static PyObject *_wrap_new_MirrorDC(PyObject *, PyObject *args, PyObject *kwargs) {
18467 PyObject *resultobj;
18468 wxDC *arg1 = 0 ;
18469 bool arg2 ;
18470 wxMirrorDC *result;
18471 PyObject * obj0 = 0 ;
18472 PyObject * obj1 = 0 ;
18473 char *kwnames[] = {
18474 (char *) "dc",(char *) "mirror", NULL
18475 };
18476
18477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_MirrorDC",kwnames,&obj0,&obj1)) goto fail;
18478 {
18479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18480 if (SWIG_arg_fail(1)) SWIG_fail;
18481 if (arg1 == NULL) {
18482 SWIG_null_ref("wxDC");
18483 }
18484 if (SWIG_arg_fail(1)) SWIG_fail;
18485 }
18486 {
18487 arg2 = (bool)(SWIG_As_bool(obj1));
18488 if (SWIG_arg_fail(2)) SWIG_fail;
18489 }
18490 {
18491 if (!wxPyCheckForApp()) SWIG_fail;
18492 PyThreadState* __tstate = wxPyBeginAllowThreads();
18493 result = (wxMirrorDC *)new wxMirrorDC(*arg1,arg2);
18494
18495 wxPyEndAllowThreads(__tstate);
18496 if (PyErr_Occurred()) SWIG_fail;
18497 }
18498 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMirrorDC, 1);
18499 return resultobj;
18500 fail:
18501 return NULL;
18502 }
18503
18504
18505 static PyObject * MirrorDC_swigregister(PyObject *, PyObject *args) {
18506 PyObject *obj;
18507 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18508 SWIG_TypeClientData(SWIGTYPE_p_wxMirrorDC, obj);
18509 Py_INCREF(obj);
18510 return Py_BuildValue((char *)"");
18511 }
18512 static PyObject *_wrap_new_PostScriptDC(PyObject *, PyObject *args, PyObject *kwargs) {
18513 PyObject *resultobj;
18514 wxPrintData *arg1 = 0 ;
18515 wxPostScriptDC *result;
18516 PyObject * obj0 = 0 ;
18517 char *kwnames[] = {
18518 (char *) "printData", NULL
18519 };
18520
18521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PostScriptDC",kwnames,&obj0)) goto fail;
18522 {
18523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18524 if (SWIG_arg_fail(1)) SWIG_fail;
18525 if (arg1 == NULL) {
18526 SWIG_null_ref("wxPrintData");
18527 }
18528 if (SWIG_arg_fail(1)) SWIG_fail;
18529 }
18530 {
18531 if (!wxPyCheckForApp()) SWIG_fail;
18532 PyThreadState* __tstate = wxPyBeginAllowThreads();
18533 result = (wxPostScriptDC *)new wxPostScriptDC((wxPrintData const &)*arg1);
18534
18535 wxPyEndAllowThreads(__tstate);
18536 if (PyErr_Occurred()) SWIG_fail;
18537 }
18538 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPostScriptDC, 1);
18539 return resultobj;
18540 fail:
18541 return NULL;
18542 }
18543
18544
18545 static PyObject *_wrap_PostScriptDC_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
18546 PyObject *resultobj;
18547 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
18548 wxPrintData *result;
18549 PyObject * obj0 = 0 ;
18550 char *kwnames[] = {
18551 (char *) "self", NULL
18552 };
18553
18554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_GetPrintData",kwnames,&obj0)) goto fail;
18555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
18556 if (SWIG_arg_fail(1)) SWIG_fail;
18557 {
18558 PyThreadState* __tstate = wxPyBeginAllowThreads();
18559 {
18560 wxPrintData &_result_ref = (arg1)->GetPrintData();
18561 result = (wxPrintData *) &_result_ref;
18562 }
18563
18564 wxPyEndAllowThreads(__tstate);
18565 if (PyErr_Occurred()) SWIG_fail;
18566 }
18567 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
18568 return resultobj;
18569 fail:
18570 return NULL;
18571 }
18572
18573
18574 static PyObject *_wrap_PostScriptDC_SetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
18575 PyObject *resultobj;
18576 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
18577 wxPrintData *arg2 = 0 ;
18578 PyObject * obj0 = 0 ;
18579 PyObject * obj1 = 0 ;
18580 char *kwnames[] = {
18581 (char *) "self",(char *) "data", NULL
18582 };
18583
18584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostScriptDC_SetPrintData",kwnames,&obj0,&obj1)) goto fail;
18585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
18586 if (SWIG_arg_fail(1)) SWIG_fail;
18587 {
18588 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18589 if (SWIG_arg_fail(2)) SWIG_fail;
18590 if (arg2 == NULL) {
18591 SWIG_null_ref("wxPrintData");
18592 }
18593 if (SWIG_arg_fail(2)) SWIG_fail;
18594 }
18595 {
18596 PyThreadState* __tstate = wxPyBeginAllowThreads();
18597 (arg1)->SetPrintData((wxPrintData const &)*arg2);
18598
18599 wxPyEndAllowThreads(__tstate);
18600 if (PyErr_Occurred()) SWIG_fail;
18601 }
18602 Py_INCREF(Py_None); resultobj = Py_None;
18603 return resultobj;
18604 fail:
18605 return NULL;
18606 }
18607
18608
18609 static PyObject *_wrap_PostScriptDC_SetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
18610 PyObject *resultobj;
18611 int arg1 ;
18612 PyObject * obj0 = 0 ;
18613 char *kwnames[] = {
18614 (char *) "ppi", NULL
18615 };
18616
18617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_SetResolution",kwnames,&obj0)) goto fail;
18618 {
18619 arg1 = (int)(SWIG_As_int(obj0));
18620 if (SWIG_arg_fail(1)) SWIG_fail;
18621 }
18622 {
18623 PyThreadState* __tstate = wxPyBeginAllowThreads();
18624 wxPostScriptDC::SetResolution(arg1);
18625
18626 wxPyEndAllowThreads(__tstate);
18627 if (PyErr_Occurred()) SWIG_fail;
18628 }
18629 Py_INCREF(Py_None); resultobj = Py_None;
18630 return resultobj;
18631 fail:
18632 return NULL;
18633 }
18634
18635
18636 static PyObject *_wrap_PostScriptDC_GetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
18637 PyObject *resultobj;
18638 int result;
18639 char *kwnames[] = {
18640 NULL
18641 };
18642
18643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PostScriptDC_GetResolution",kwnames)) goto fail;
18644 {
18645 PyThreadState* __tstate = wxPyBeginAllowThreads();
18646 result = (int)wxPostScriptDC::GetResolution();
18647
18648 wxPyEndAllowThreads(__tstate);
18649 if (PyErr_Occurred()) SWIG_fail;
18650 }
18651 {
18652 resultobj = SWIG_From_int((int)(result));
18653 }
18654 return resultobj;
18655 fail:
18656 return NULL;
18657 }
18658
18659
18660 static PyObject * PostScriptDC_swigregister(PyObject *, PyObject *args) {
18661 PyObject *obj;
18662 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18663 SWIG_TypeClientData(SWIGTYPE_p_wxPostScriptDC, obj);
18664 Py_INCREF(obj);
18665 return Py_BuildValue((char *)"");
18666 }
18667 static PyObject *_wrap_new_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
18668 PyObject *resultobj;
18669 wxString const &arg1_defvalue = wxPyEmptyString ;
18670 wxString *arg1 = (wxString *) &arg1_defvalue ;
18671 wxMetaFile *result;
18672 bool temp1 = false ;
18673 PyObject * obj0 = 0 ;
18674 char *kwnames[] = {
18675 (char *) "filename", NULL
18676 };
18677
18678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MetaFile",kwnames,&obj0)) goto fail;
18679 if (obj0) {
18680 {
18681 arg1 = wxString_in_helper(obj0);
18682 if (arg1 == NULL) SWIG_fail;
18683 temp1 = true;
18684 }
18685 }
18686 {
18687 if (!wxPyCheckForApp()) SWIG_fail;
18688 PyThreadState* __tstate = wxPyBeginAllowThreads();
18689 result = (wxMetaFile *)new wxMetaFile((wxString const &)*arg1);
18690
18691 wxPyEndAllowThreads(__tstate);
18692 if (PyErr_Occurred()) SWIG_fail;
18693 }
18694 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 1);
18695 {
18696 if (temp1)
18697 delete arg1;
18698 }
18699 return resultobj;
18700 fail:
18701 {
18702 if (temp1)
18703 delete arg1;
18704 }
18705 return NULL;
18706 }
18707
18708
18709 static PyObject *_wrap_delete_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
18710 PyObject *resultobj;
18711 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18712 PyObject * obj0 = 0 ;
18713 char *kwnames[] = {
18714 (char *) "self", NULL
18715 };
18716
18717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MetaFile",kwnames,&obj0)) goto fail;
18718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18719 if (SWIG_arg_fail(1)) SWIG_fail;
18720 {
18721 PyThreadState* __tstate = wxPyBeginAllowThreads();
18722 delete arg1;
18723
18724 wxPyEndAllowThreads(__tstate);
18725 if (PyErr_Occurred()) SWIG_fail;
18726 }
18727 Py_INCREF(Py_None); resultobj = Py_None;
18728 return resultobj;
18729 fail:
18730 return NULL;
18731 }
18732
18733
18734 static PyObject *_wrap_MetaFile_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
18735 PyObject *resultobj;
18736 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18737 bool result;
18738 PyObject * obj0 = 0 ;
18739 char *kwnames[] = {
18740 (char *) "self", NULL
18741 };
18742
18743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_Ok",kwnames,&obj0)) goto fail;
18744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18745 if (SWIG_arg_fail(1)) SWIG_fail;
18746 {
18747 PyThreadState* __tstate = wxPyBeginAllowThreads();
18748 result = (bool)(arg1)->Ok();
18749
18750 wxPyEndAllowThreads(__tstate);
18751 if (PyErr_Occurred()) SWIG_fail;
18752 }
18753 {
18754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18755 }
18756 return resultobj;
18757 fail:
18758 return NULL;
18759 }
18760
18761
18762 static PyObject *_wrap_MetaFile_SetClipboard(PyObject *, PyObject *args, PyObject *kwargs) {
18763 PyObject *resultobj;
18764 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18765 int arg2 = (int) 0 ;
18766 int arg3 = (int) 0 ;
18767 bool result;
18768 PyObject * obj0 = 0 ;
18769 PyObject * obj1 = 0 ;
18770 PyObject * obj2 = 0 ;
18771 char *kwnames[] = {
18772 (char *) "self",(char *) "width",(char *) "height", NULL
18773 };
18774
18775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MetaFile_SetClipboard",kwnames,&obj0,&obj1,&obj2)) goto fail;
18776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18777 if (SWIG_arg_fail(1)) SWIG_fail;
18778 if (obj1) {
18779 {
18780 arg2 = (int)(SWIG_As_int(obj1));
18781 if (SWIG_arg_fail(2)) SWIG_fail;
18782 }
18783 }
18784 if (obj2) {
18785 {
18786 arg3 = (int)(SWIG_As_int(obj2));
18787 if (SWIG_arg_fail(3)) SWIG_fail;
18788 }
18789 }
18790 {
18791 PyThreadState* __tstate = wxPyBeginAllowThreads();
18792 result = (bool)(arg1)->SetClipboard(arg2,arg3);
18793
18794 wxPyEndAllowThreads(__tstate);
18795 if (PyErr_Occurred()) SWIG_fail;
18796 }
18797 {
18798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18799 }
18800 return resultobj;
18801 fail:
18802 return NULL;
18803 }
18804
18805
18806 static PyObject *_wrap_MetaFile_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18807 PyObject *resultobj;
18808 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18809 wxSize result;
18810 PyObject * obj0 = 0 ;
18811 char *kwnames[] = {
18812 (char *) "self", NULL
18813 };
18814
18815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetSize",kwnames,&obj0)) goto fail;
18816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18817 if (SWIG_arg_fail(1)) SWIG_fail;
18818 {
18819 PyThreadState* __tstate = wxPyBeginAllowThreads();
18820 result = (arg1)->GetSize();
18821
18822 wxPyEndAllowThreads(__tstate);
18823 if (PyErr_Occurred()) SWIG_fail;
18824 }
18825 {
18826 wxSize * resultptr;
18827 resultptr = new wxSize((wxSize &)(result));
18828 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18829 }
18830 return resultobj;
18831 fail:
18832 return NULL;
18833 }
18834
18835
18836 static PyObject *_wrap_MetaFile_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
18837 PyObject *resultobj;
18838 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18839 int result;
18840 PyObject * obj0 = 0 ;
18841 char *kwnames[] = {
18842 (char *) "self", NULL
18843 };
18844
18845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetWidth",kwnames,&obj0)) goto fail;
18846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18847 if (SWIG_arg_fail(1)) SWIG_fail;
18848 {
18849 PyThreadState* __tstate = wxPyBeginAllowThreads();
18850 result = (int)(arg1)->GetWidth();
18851
18852 wxPyEndAllowThreads(__tstate);
18853 if (PyErr_Occurred()) SWIG_fail;
18854 }
18855 {
18856 resultobj = SWIG_From_int((int)(result));
18857 }
18858 return resultobj;
18859 fail:
18860 return NULL;
18861 }
18862
18863
18864 static PyObject *_wrap_MetaFile_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
18865 PyObject *resultobj;
18866 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18867 int result;
18868 PyObject * obj0 = 0 ;
18869 char *kwnames[] = {
18870 (char *) "self", NULL
18871 };
18872
18873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetHeight",kwnames,&obj0)) goto fail;
18874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18875 if (SWIG_arg_fail(1)) SWIG_fail;
18876 {
18877 PyThreadState* __tstate = wxPyBeginAllowThreads();
18878 result = (int)(arg1)->GetHeight();
18879
18880 wxPyEndAllowThreads(__tstate);
18881 if (PyErr_Occurred()) SWIG_fail;
18882 }
18883 {
18884 resultobj = SWIG_From_int((int)(result));
18885 }
18886 return resultobj;
18887 fail:
18888 return NULL;
18889 }
18890
18891
18892 static PyObject *_wrap_MetaFile_GetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
18893 PyObject *resultobj;
18894 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18895 wxString *result;
18896 PyObject * obj0 = 0 ;
18897 char *kwnames[] = {
18898 (char *) "self", NULL
18899 };
18900
18901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetFileName",kwnames,&obj0)) goto fail;
18902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18903 if (SWIG_arg_fail(1)) SWIG_fail;
18904 {
18905 PyThreadState* __tstate = wxPyBeginAllowThreads();
18906 {
18907 wxString const &_result_ref = ((wxMetaFile const *)arg1)->GetFileName();
18908 result = (wxString *) &_result_ref;
18909 }
18910
18911 wxPyEndAllowThreads(__tstate);
18912 if (PyErr_Occurred()) SWIG_fail;
18913 }
18914 {
18915 #if wxUSE_UNICODE
18916 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18917 #else
18918 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18919 #endif
18920 }
18921 return resultobj;
18922 fail:
18923 return NULL;
18924 }
18925
18926
18927 static PyObject * MetaFile_swigregister(PyObject *, PyObject *args) {
18928 PyObject *obj;
18929 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18930 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFile, obj);
18931 Py_INCREF(obj);
18932 return Py_BuildValue((char *)"");
18933 }
18934 static PyObject *_wrap_new_MetaFileDC(PyObject *, PyObject *args, PyObject *kwargs) {
18935 PyObject *resultobj;
18936 wxString const &arg1_defvalue = wxPyEmptyString ;
18937 wxString *arg1 = (wxString *) &arg1_defvalue ;
18938 int arg2 = (int) 0 ;
18939 int arg3 = (int) 0 ;
18940 wxString const &arg4_defvalue = wxPyEmptyString ;
18941 wxString *arg4 = (wxString *) &arg4_defvalue ;
18942 wxMetaFileDC *result;
18943 bool temp1 = false ;
18944 bool temp4 = false ;
18945 PyObject * obj0 = 0 ;
18946 PyObject * obj1 = 0 ;
18947 PyObject * obj2 = 0 ;
18948 PyObject * obj3 = 0 ;
18949 char *kwnames[] = {
18950 (char *) "filename",(char *) "width",(char *) "height",(char *) "description", NULL
18951 };
18952
18953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_MetaFileDC",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18954 if (obj0) {
18955 {
18956 arg1 = wxString_in_helper(obj0);
18957 if (arg1 == NULL) SWIG_fail;
18958 temp1 = true;
18959 }
18960 }
18961 if (obj1) {
18962 {
18963 arg2 = (int)(SWIG_As_int(obj1));
18964 if (SWIG_arg_fail(2)) SWIG_fail;
18965 }
18966 }
18967 if (obj2) {
18968 {
18969 arg3 = (int)(SWIG_As_int(obj2));
18970 if (SWIG_arg_fail(3)) SWIG_fail;
18971 }
18972 }
18973 if (obj3) {
18974 {
18975 arg4 = wxString_in_helper(obj3);
18976 if (arg4 == NULL) SWIG_fail;
18977 temp4 = true;
18978 }
18979 }
18980 {
18981 if (!wxPyCheckForApp()) SWIG_fail;
18982 PyThreadState* __tstate = wxPyBeginAllowThreads();
18983 result = (wxMetaFileDC *)new wxMetaFileDC((wxString const &)*arg1,arg2,arg3,(wxString const &)*arg4);
18984
18985 wxPyEndAllowThreads(__tstate);
18986 if (PyErr_Occurred()) SWIG_fail;
18987 }
18988 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFileDC, 1);
18989 {
18990 if (temp1)
18991 delete arg1;
18992 }
18993 {
18994 if (temp4)
18995 delete arg4;
18996 }
18997 return resultobj;
18998 fail:
18999 {
19000 if (temp1)
19001 delete arg1;
19002 }
19003 {
19004 if (temp4)
19005 delete arg4;
19006 }
19007 return NULL;
19008 }
19009
19010
19011 static PyObject *_wrap_MetaFileDC_Close(PyObject *, PyObject *args, PyObject *kwargs) {
19012 PyObject *resultobj;
19013 wxMetaFileDC *arg1 = (wxMetaFileDC *) 0 ;
19014 wxMetaFile *result;
19015 PyObject * obj0 = 0 ;
19016 char *kwnames[] = {
19017 (char *) "self", NULL
19018 };
19019
19020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFileDC_Close",kwnames,&obj0)) goto fail;
19021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFileDC, SWIG_POINTER_EXCEPTION | 0);
19022 if (SWIG_arg_fail(1)) SWIG_fail;
19023 {
19024 PyThreadState* __tstate = wxPyBeginAllowThreads();
19025 result = (wxMetaFile *)(arg1)->Close();
19026
19027 wxPyEndAllowThreads(__tstate);
19028 if (PyErr_Occurred()) SWIG_fail;
19029 }
19030 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 0);
19031 return resultobj;
19032 fail:
19033 return NULL;
19034 }
19035
19036
19037 static PyObject * MetaFileDC_swigregister(PyObject *, PyObject *args) {
19038 PyObject *obj;
19039 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19040 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFileDC, obj);
19041 Py_INCREF(obj);
19042 return Py_BuildValue((char *)"");
19043 }
19044 static PyObject *_wrap_new_PrinterDC(PyObject *, PyObject *args, PyObject *kwargs) {
19045 PyObject *resultobj;
19046 wxPrintData *arg1 = 0 ;
19047 wxPrinterDC *result;
19048 PyObject * obj0 = 0 ;
19049 char *kwnames[] = {
19050 (char *) "printData", NULL
19051 };
19052
19053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PrinterDC",kwnames,&obj0)) goto fail;
19054 {
19055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
19056 if (SWIG_arg_fail(1)) SWIG_fail;
19057 if (arg1 == NULL) {
19058 SWIG_null_ref("wxPrintData");
19059 }
19060 if (SWIG_arg_fail(1)) SWIG_fail;
19061 }
19062 {
19063 if (!wxPyCheckForApp()) SWIG_fail;
19064 PyThreadState* __tstate = wxPyBeginAllowThreads();
19065 result = (wxPrinterDC *)new wxPrinterDC((wxPrintData const &)*arg1);
19066
19067 wxPyEndAllowThreads(__tstate);
19068 if (PyErr_Occurred()) SWIG_fail;
19069 }
19070 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrinterDC, 1);
19071 return resultobj;
19072 fail:
19073 return NULL;
19074 }
19075
19076
19077 static PyObject * PrinterDC_swigregister(PyObject *, PyObject *args) {
19078 PyObject *obj;
19079 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19080 SWIG_TypeClientData(SWIGTYPE_p_wxPrinterDC, obj);
19081 Py_INCREF(obj);
19082 return Py_BuildValue((char *)"");
19083 }
19084 static PyObject *_wrap_new_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
19085 PyObject *resultobj;
19086 int arg1 ;
19087 int arg2 ;
19088 int arg3 = (int) true ;
19089 int arg4 = (int) 1 ;
19090 wxImageList *result;
19091 PyObject * obj0 = 0 ;
19092 PyObject * obj1 = 0 ;
19093 PyObject * obj2 = 0 ;
19094 PyObject * obj3 = 0 ;
19095 char *kwnames[] = {
19096 (char *) "width",(char *) "height",(char *) "mask",(char *) "initialCount", NULL
19097 };
19098
19099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_ImageList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19100 {
19101 arg1 = (int)(SWIG_As_int(obj0));
19102 if (SWIG_arg_fail(1)) SWIG_fail;
19103 }
19104 {
19105 arg2 = (int)(SWIG_As_int(obj1));
19106 if (SWIG_arg_fail(2)) SWIG_fail;
19107 }
19108 if (obj2) {
19109 {
19110 arg3 = (int)(SWIG_As_int(obj2));
19111 if (SWIG_arg_fail(3)) SWIG_fail;
19112 }
19113 }
19114 if (obj3) {
19115 {
19116 arg4 = (int)(SWIG_As_int(obj3));
19117 if (SWIG_arg_fail(4)) SWIG_fail;
19118 }
19119 }
19120 {
19121 if (!wxPyCheckForApp()) SWIG_fail;
19122 PyThreadState* __tstate = wxPyBeginAllowThreads();
19123 result = (wxImageList *)new wxImageList(arg1,arg2,arg3,arg4);
19124
19125 wxPyEndAllowThreads(__tstate);
19126 if (PyErr_Occurred()) SWIG_fail;
19127 }
19128 {
19129 resultobj = wxPyMake_wxObject(result, 1);
19130 }
19131 return resultobj;
19132 fail:
19133 return NULL;
19134 }
19135
19136
19137 static PyObject *_wrap_delete_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
19138 PyObject *resultobj;
19139 wxImageList *arg1 = (wxImageList *) 0 ;
19140 PyObject * obj0 = 0 ;
19141 char *kwnames[] = {
19142 (char *) "self", NULL
19143 };
19144
19145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ImageList",kwnames,&obj0)) goto fail;
19146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19147 if (SWIG_arg_fail(1)) SWIG_fail;
19148 {
19149 PyThreadState* __tstate = wxPyBeginAllowThreads();
19150 delete arg1;
19151
19152 wxPyEndAllowThreads(__tstate);
19153 if (PyErr_Occurred()) SWIG_fail;
19154 }
19155 Py_INCREF(Py_None); resultobj = Py_None;
19156 return resultobj;
19157 fail:
19158 return NULL;
19159 }
19160
19161
19162 static PyObject *_wrap_ImageList_Add(PyObject *, PyObject *args, PyObject *kwargs) {
19163 PyObject *resultobj;
19164 wxImageList *arg1 = (wxImageList *) 0 ;
19165 wxBitmap *arg2 = 0 ;
19166 wxBitmap const &arg3_defvalue = wxNullBitmap ;
19167 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
19168 int result;
19169 PyObject * obj0 = 0 ;
19170 PyObject * obj1 = 0 ;
19171 PyObject * obj2 = 0 ;
19172 char *kwnames[] = {
19173 (char *) "self",(char *) "bitmap",(char *) "mask", NULL
19174 };
19175
19176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ImageList_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
19177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19178 if (SWIG_arg_fail(1)) SWIG_fail;
19179 {
19180 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19181 if (SWIG_arg_fail(2)) SWIG_fail;
19182 if (arg2 == NULL) {
19183 SWIG_null_ref("wxBitmap");
19184 }
19185 if (SWIG_arg_fail(2)) SWIG_fail;
19186 }
19187 if (obj2) {
19188 {
19189 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19190 if (SWIG_arg_fail(3)) SWIG_fail;
19191 if (arg3 == NULL) {
19192 SWIG_null_ref("wxBitmap");
19193 }
19194 if (SWIG_arg_fail(3)) SWIG_fail;
19195 }
19196 }
19197 {
19198 PyThreadState* __tstate = wxPyBeginAllowThreads();
19199 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
19200
19201 wxPyEndAllowThreads(__tstate);
19202 if (PyErr_Occurred()) SWIG_fail;
19203 }
19204 {
19205 resultobj = SWIG_From_int((int)(result));
19206 }
19207 return resultobj;
19208 fail:
19209 return NULL;
19210 }
19211
19212
19213 static PyObject *_wrap_ImageList_AddWithColourMask(PyObject *, PyObject *args, PyObject *kwargs) {
19214 PyObject *resultobj;
19215 wxImageList *arg1 = (wxImageList *) 0 ;
19216 wxBitmap *arg2 = 0 ;
19217 wxColour *arg3 = 0 ;
19218 int result;
19219 wxColour temp3 ;
19220 PyObject * obj0 = 0 ;
19221 PyObject * obj1 = 0 ;
19222 PyObject * obj2 = 0 ;
19223 char *kwnames[] = {
19224 (char *) "self",(char *) "bitmap",(char *) "maskColour", NULL
19225 };
19226
19227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_AddWithColourMask",kwnames,&obj0,&obj1,&obj2)) goto fail;
19228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19229 if (SWIG_arg_fail(1)) SWIG_fail;
19230 {
19231 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19232 if (SWIG_arg_fail(2)) SWIG_fail;
19233 if (arg2 == NULL) {
19234 SWIG_null_ref("wxBitmap");
19235 }
19236 if (SWIG_arg_fail(2)) SWIG_fail;
19237 }
19238 {
19239 arg3 = &temp3;
19240 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
19241 }
19242 {
19243 PyThreadState* __tstate = wxPyBeginAllowThreads();
19244 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxColour const &)*arg3);
19245
19246 wxPyEndAllowThreads(__tstate);
19247 if (PyErr_Occurred()) SWIG_fail;
19248 }
19249 {
19250 resultobj = SWIG_From_int((int)(result));
19251 }
19252 return resultobj;
19253 fail:
19254 return NULL;
19255 }
19256
19257
19258 static PyObject *_wrap_ImageList_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
19259 PyObject *resultobj;
19260 wxImageList *arg1 = (wxImageList *) 0 ;
19261 wxIcon *arg2 = 0 ;
19262 int result;
19263 PyObject * obj0 = 0 ;
19264 PyObject * obj1 = 0 ;
19265 char *kwnames[] = {
19266 (char *) "self",(char *) "icon", NULL
19267 };
19268
19269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_AddIcon",kwnames,&obj0,&obj1)) goto fail;
19270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19271 if (SWIG_arg_fail(1)) SWIG_fail;
19272 {
19273 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
19274 if (SWIG_arg_fail(2)) SWIG_fail;
19275 if (arg2 == NULL) {
19276 SWIG_null_ref("wxIcon");
19277 }
19278 if (SWIG_arg_fail(2)) SWIG_fail;
19279 }
19280 {
19281 PyThreadState* __tstate = wxPyBeginAllowThreads();
19282 result = (int)(arg1)->Add((wxIcon const &)*arg2);
19283
19284 wxPyEndAllowThreads(__tstate);
19285 if (PyErr_Occurred()) SWIG_fail;
19286 }
19287 {
19288 resultobj = SWIG_From_int((int)(result));
19289 }
19290 return resultobj;
19291 fail:
19292 return NULL;
19293 }
19294
19295
19296 static PyObject *_wrap_ImageList_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
19297 PyObject *resultobj;
19298 wxImageList *arg1 = (wxImageList *) 0 ;
19299 int arg2 ;
19300 SwigValueWrapper<wxBitmap > result;
19301 PyObject * obj0 = 0 ;
19302 PyObject * obj1 = 0 ;
19303 char *kwnames[] = {
19304 (char *) "self",(char *) "index", NULL
19305 };
19306
19307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetBitmap",kwnames,&obj0,&obj1)) goto fail;
19308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19309 if (SWIG_arg_fail(1)) SWIG_fail;
19310 {
19311 arg2 = (int)(SWIG_As_int(obj1));
19312 if (SWIG_arg_fail(2)) SWIG_fail;
19313 }
19314 {
19315 PyThreadState* __tstate = wxPyBeginAllowThreads();
19316 result = ((wxImageList const *)arg1)->GetBitmap(arg2);
19317
19318 wxPyEndAllowThreads(__tstate);
19319 if (PyErr_Occurred()) SWIG_fail;
19320 }
19321 {
19322 wxBitmap * resultptr;
19323 resultptr = new wxBitmap((wxBitmap &)(result));
19324 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
19325 }
19326 return resultobj;
19327 fail:
19328 return NULL;
19329 }
19330
19331
19332 static PyObject *_wrap_ImageList_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
19333 PyObject *resultobj;
19334 wxImageList *arg1 = (wxImageList *) 0 ;
19335 int arg2 ;
19336 wxIcon result;
19337 PyObject * obj0 = 0 ;
19338 PyObject * obj1 = 0 ;
19339 char *kwnames[] = {
19340 (char *) "self",(char *) "index", NULL
19341 };
19342
19343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetIcon",kwnames,&obj0,&obj1)) goto fail;
19344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19345 if (SWIG_arg_fail(1)) SWIG_fail;
19346 {
19347 arg2 = (int)(SWIG_As_int(obj1));
19348 if (SWIG_arg_fail(2)) SWIG_fail;
19349 }
19350 {
19351 PyThreadState* __tstate = wxPyBeginAllowThreads();
19352 result = ((wxImageList const *)arg1)->GetIcon(arg2);
19353
19354 wxPyEndAllowThreads(__tstate);
19355 if (PyErr_Occurred()) SWIG_fail;
19356 }
19357 {
19358 wxIcon * resultptr;
19359 resultptr = new wxIcon((wxIcon &)(result));
19360 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
19361 }
19362 return resultobj;
19363 fail:
19364 return NULL;
19365 }
19366
19367
19368 static PyObject *_wrap_ImageList_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
19369 PyObject *resultobj;
19370 wxImageList *arg1 = (wxImageList *) 0 ;
19371 int arg2 ;
19372 wxBitmap *arg3 = 0 ;
19373 wxBitmap const &arg4_defvalue = wxNullBitmap ;
19374 wxBitmap *arg4 = (wxBitmap *) &arg4_defvalue ;
19375 bool result;
19376 PyObject * obj0 = 0 ;
19377 PyObject * obj1 = 0 ;
19378 PyObject * obj2 = 0 ;
19379 PyObject * obj3 = 0 ;
19380 char *kwnames[] = {
19381 (char *) "self",(char *) "index",(char *) "bitmap",(char *) "mask", NULL
19382 };
19383
19384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ImageList_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19386 if (SWIG_arg_fail(1)) SWIG_fail;
19387 {
19388 arg2 = (int)(SWIG_As_int(obj1));
19389 if (SWIG_arg_fail(2)) SWIG_fail;
19390 }
19391 {
19392 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19393 if (SWIG_arg_fail(3)) SWIG_fail;
19394 if (arg3 == NULL) {
19395 SWIG_null_ref("wxBitmap");
19396 }
19397 if (SWIG_arg_fail(3)) SWIG_fail;
19398 }
19399 if (obj3) {
19400 {
19401 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19402 if (SWIG_arg_fail(4)) SWIG_fail;
19403 if (arg4 == NULL) {
19404 SWIG_null_ref("wxBitmap");
19405 }
19406 if (SWIG_arg_fail(4)) SWIG_fail;
19407 }
19408 }
19409 {
19410 PyThreadState* __tstate = wxPyBeginAllowThreads();
19411 result = (bool)(arg1)->Replace(arg2,(wxBitmap const &)*arg3,(wxBitmap const &)*arg4);
19412
19413 wxPyEndAllowThreads(__tstate);
19414 if (PyErr_Occurred()) SWIG_fail;
19415 }
19416 {
19417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19418 }
19419 return resultobj;
19420 fail:
19421 return NULL;
19422 }
19423
19424
19425 static PyObject *_wrap_ImageList_Draw(PyObject *, PyObject *args, PyObject *kwargs) {
19426 PyObject *resultobj;
19427 wxImageList *arg1 = (wxImageList *) 0 ;
19428 int arg2 ;
19429 wxDC *arg3 = 0 ;
19430 int arg4 ;
19431 int arg5 ;
19432 int arg6 = (int) wxIMAGELIST_DRAW_NORMAL ;
19433 bool arg7 = (bool) (bool)false ;
19434 bool result;
19435 PyObject * obj0 = 0 ;
19436 PyObject * obj1 = 0 ;
19437 PyObject * obj2 = 0 ;
19438 PyObject * obj3 = 0 ;
19439 PyObject * obj4 = 0 ;
19440 PyObject * obj5 = 0 ;
19441 PyObject * obj6 = 0 ;
19442 char *kwnames[] = {
19443 (char *) "self",(char *) "index",(char *) "dc",(char *) "x",(char *) "x",(char *) "flags",(char *) "solidBackground", NULL
19444 };
19445
19446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OO:ImageList_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19448 if (SWIG_arg_fail(1)) SWIG_fail;
19449 {
19450 arg2 = (int)(SWIG_As_int(obj1));
19451 if (SWIG_arg_fail(2)) SWIG_fail;
19452 }
19453 {
19454 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19455 if (SWIG_arg_fail(3)) SWIG_fail;
19456 if (arg3 == NULL) {
19457 SWIG_null_ref("wxDC");
19458 }
19459 if (SWIG_arg_fail(3)) SWIG_fail;
19460 }
19461 {
19462 arg4 = (int)(SWIG_As_int(obj3));
19463 if (SWIG_arg_fail(4)) SWIG_fail;
19464 }
19465 {
19466 arg5 = (int)(SWIG_As_int(obj4));
19467 if (SWIG_arg_fail(5)) SWIG_fail;
19468 }
19469 if (obj5) {
19470 {
19471 arg6 = (int)(SWIG_As_int(obj5));
19472 if (SWIG_arg_fail(6)) SWIG_fail;
19473 }
19474 }
19475 if (obj6) {
19476 {
19477 arg7 = (bool const)(SWIG_As_bool(obj6));
19478 if (SWIG_arg_fail(7)) SWIG_fail;
19479 }
19480 }
19481 {
19482 PyThreadState* __tstate = wxPyBeginAllowThreads();
19483 result = (bool)(arg1)->Draw(arg2,*arg3,arg4,arg5,arg6,arg7);
19484
19485 wxPyEndAllowThreads(__tstate);
19486 if (PyErr_Occurred()) SWIG_fail;
19487 }
19488 {
19489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19490 }
19491 return resultobj;
19492 fail:
19493 return NULL;
19494 }
19495
19496
19497 static PyObject *_wrap_ImageList_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
19498 PyObject *resultobj;
19499 wxImageList *arg1 = (wxImageList *) 0 ;
19500 int result;
19501 PyObject * obj0 = 0 ;
19502 char *kwnames[] = {
19503 (char *) "self", NULL
19504 };
19505
19506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_GetImageCount",kwnames,&obj0)) goto fail;
19507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19508 if (SWIG_arg_fail(1)) SWIG_fail;
19509 {
19510 PyThreadState* __tstate = wxPyBeginAllowThreads();
19511 result = (int)(arg1)->GetImageCount();
19512
19513 wxPyEndAllowThreads(__tstate);
19514 if (PyErr_Occurred()) SWIG_fail;
19515 }
19516 {
19517 resultobj = SWIG_From_int((int)(result));
19518 }
19519 return resultobj;
19520 fail:
19521 return NULL;
19522 }
19523
19524
19525 static PyObject *_wrap_ImageList_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
19526 PyObject *resultobj;
19527 wxImageList *arg1 = (wxImageList *) 0 ;
19528 int arg2 ;
19529 bool result;
19530 PyObject * obj0 = 0 ;
19531 PyObject * obj1 = 0 ;
19532 char *kwnames[] = {
19533 (char *) "self",(char *) "index", NULL
19534 };
19535
19536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_Remove",kwnames,&obj0,&obj1)) goto fail;
19537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19538 if (SWIG_arg_fail(1)) SWIG_fail;
19539 {
19540 arg2 = (int)(SWIG_As_int(obj1));
19541 if (SWIG_arg_fail(2)) SWIG_fail;
19542 }
19543 {
19544 PyThreadState* __tstate = wxPyBeginAllowThreads();
19545 result = (bool)(arg1)->Remove(arg2);
19546
19547 wxPyEndAllowThreads(__tstate);
19548 if (PyErr_Occurred()) SWIG_fail;
19549 }
19550 {
19551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19552 }
19553 return resultobj;
19554 fail:
19555 return NULL;
19556 }
19557
19558
19559 static PyObject *_wrap_ImageList_RemoveAll(PyObject *, PyObject *args, PyObject *kwargs) {
19560 PyObject *resultobj;
19561 wxImageList *arg1 = (wxImageList *) 0 ;
19562 bool result;
19563 PyObject * obj0 = 0 ;
19564 char *kwnames[] = {
19565 (char *) "self", NULL
19566 };
19567
19568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_RemoveAll",kwnames,&obj0)) goto fail;
19569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19570 if (SWIG_arg_fail(1)) SWIG_fail;
19571 {
19572 PyThreadState* __tstate = wxPyBeginAllowThreads();
19573 result = (bool)(arg1)->RemoveAll();
19574
19575 wxPyEndAllowThreads(__tstate);
19576 if (PyErr_Occurred()) SWIG_fail;
19577 }
19578 {
19579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19580 }
19581 return resultobj;
19582 fail:
19583 return NULL;
19584 }
19585
19586
19587 static PyObject *_wrap_ImageList_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19588 PyObject *resultobj;
19589 wxImageList *arg1 = (wxImageList *) 0 ;
19590 int arg2 ;
19591 int *arg3 = 0 ;
19592 int *arg4 = 0 ;
19593 int temp3 ;
19594 int res3 = 0 ;
19595 int temp4 ;
19596 int res4 = 0 ;
19597 PyObject * obj0 = 0 ;
19598 PyObject * obj1 = 0 ;
19599 char *kwnames[] = {
19600 (char *) "self",(char *) "index", NULL
19601 };
19602
19603 arg3 = &temp3; res3 = SWIG_NEWOBJ;
19604 arg4 = &temp4; res4 = SWIG_NEWOBJ;
19605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetSize",kwnames,&obj0,&obj1)) goto fail;
19606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19607 if (SWIG_arg_fail(1)) SWIG_fail;
19608 {
19609 arg2 = (int)(SWIG_As_int(obj1));
19610 if (SWIG_arg_fail(2)) SWIG_fail;
19611 }
19612 {
19613 PyThreadState* __tstate = wxPyBeginAllowThreads();
19614 (arg1)->GetSize(arg2,*arg3,*arg4);
19615
19616 wxPyEndAllowThreads(__tstate);
19617 if (PyErr_Occurred()) SWIG_fail;
19618 }
19619 Py_INCREF(Py_None); resultobj = Py_None;
19620 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19621 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
19622 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
19623 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
19624 return resultobj;
19625 fail:
19626 return NULL;
19627 }
19628
19629
19630 static PyObject * ImageList_swigregister(PyObject *, PyObject *args) {
19631 PyObject *obj;
19632 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19633 SWIG_TypeClientData(SWIGTYPE_p_wxImageList, obj);
19634 Py_INCREF(obj);
19635 return Py_BuildValue((char *)"");
19636 }
19637 static int _wrap_NORMAL_FONT_set(PyObject *) {
19638 PyErr_SetString(PyExc_TypeError,"Variable NORMAL_FONT is read-only.");
19639 return 1;
19640 }
19641
19642
19643 static PyObject *_wrap_NORMAL_FONT_get(void) {
19644 PyObject *pyobj;
19645
19646 pyobj = SWIG_NewPointerObj((void *)(wxNORMAL_FONT), SWIGTYPE_p_wxFont, 0);
19647 return pyobj;
19648 }
19649
19650
19651 static int _wrap_SMALL_FONT_set(PyObject *) {
19652 PyErr_SetString(PyExc_TypeError,"Variable SMALL_FONT is read-only.");
19653 return 1;
19654 }
19655
19656
19657 static PyObject *_wrap_SMALL_FONT_get(void) {
19658 PyObject *pyobj;
19659
19660 pyobj = SWIG_NewPointerObj((void *)(wxSMALL_FONT), SWIGTYPE_p_wxFont, 0);
19661 return pyobj;
19662 }
19663
19664
19665 static int _wrap_ITALIC_FONT_set(PyObject *) {
19666 PyErr_SetString(PyExc_TypeError,"Variable ITALIC_FONT is read-only.");
19667 return 1;
19668 }
19669
19670
19671 static PyObject *_wrap_ITALIC_FONT_get(void) {
19672 PyObject *pyobj;
19673
19674 pyobj = SWIG_NewPointerObj((void *)(wxITALIC_FONT), SWIGTYPE_p_wxFont, 0);
19675 return pyobj;
19676 }
19677
19678
19679 static int _wrap_SWISS_FONT_set(PyObject *) {
19680 PyErr_SetString(PyExc_TypeError,"Variable SWISS_FONT is read-only.");
19681 return 1;
19682 }
19683
19684
19685 static PyObject *_wrap_SWISS_FONT_get(void) {
19686 PyObject *pyobj;
19687
19688 pyobj = SWIG_NewPointerObj((void *)(wxSWISS_FONT), SWIGTYPE_p_wxFont, 0);
19689 return pyobj;
19690 }
19691
19692
19693 static int _wrap_RED_PEN_set(PyObject *) {
19694 PyErr_SetString(PyExc_TypeError,"Variable RED_PEN is read-only.");
19695 return 1;
19696 }
19697
19698
19699 static PyObject *_wrap_RED_PEN_get(void) {
19700 PyObject *pyobj;
19701
19702 pyobj = SWIG_NewPointerObj((void *)(wxRED_PEN), SWIGTYPE_p_wxPen, 0);
19703 return pyobj;
19704 }
19705
19706
19707 static int _wrap_CYAN_PEN_set(PyObject *) {
19708 PyErr_SetString(PyExc_TypeError,"Variable CYAN_PEN is read-only.");
19709 return 1;
19710 }
19711
19712
19713 static PyObject *_wrap_CYAN_PEN_get(void) {
19714 PyObject *pyobj;
19715
19716 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_PEN), SWIGTYPE_p_wxPen, 0);
19717 return pyobj;
19718 }
19719
19720
19721 static int _wrap_GREEN_PEN_set(PyObject *) {
19722 PyErr_SetString(PyExc_TypeError,"Variable GREEN_PEN is read-only.");
19723 return 1;
19724 }
19725
19726
19727 static PyObject *_wrap_GREEN_PEN_get(void) {
19728 PyObject *pyobj;
19729
19730 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_PEN), SWIGTYPE_p_wxPen, 0);
19731 return pyobj;
19732 }
19733
19734
19735 static int _wrap_BLACK_PEN_set(PyObject *) {
19736 PyErr_SetString(PyExc_TypeError,"Variable BLACK_PEN is read-only.");
19737 return 1;
19738 }
19739
19740
19741 static PyObject *_wrap_BLACK_PEN_get(void) {
19742 PyObject *pyobj;
19743
19744 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_PEN), SWIGTYPE_p_wxPen, 0);
19745 return pyobj;
19746 }
19747
19748
19749 static int _wrap_WHITE_PEN_set(PyObject *) {
19750 PyErr_SetString(PyExc_TypeError,"Variable WHITE_PEN is read-only.");
19751 return 1;
19752 }
19753
19754
19755 static PyObject *_wrap_WHITE_PEN_get(void) {
19756 PyObject *pyobj;
19757
19758 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_PEN), SWIGTYPE_p_wxPen, 0);
19759 return pyobj;
19760 }
19761
19762
19763 static int _wrap_TRANSPARENT_PEN_set(PyObject *) {
19764 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_PEN is read-only.");
19765 return 1;
19766 }
19767
19768
19769 static PyObject *_wrap_TRANSPARENT_PEN_get(void) {
19770 PyObject *pyobj;
19771
19772 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_PEN), SWIGTYPE_p_wxPen, 0);
19773 return pyobj;
19774 }
19775
19776
19777 static int _wrap_BLACK_DASHED_PEN_set(PyObject *) {
19778 PyErr_SetString(PyExc_TypeError,"Variable BLACK_DASHED_PEN is read-only.");
19779 return 1;
19780 }
19781
19782
19783 static PyObject *_wrap_BLACK_DASHED_PEN_get(void) {
19784 PyObject *pyobj;
19785
19786 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_DASHED_PEN), SWIGTYPE_p_wxPen, 0);
19787 return pyobj;
19788 }
19789
19790
19791 static int _wrap_GREY_PEN_set(PyObject *) {
19792 PyErr_SetString(PyExc_TypeError,"Variable GREY_PEN is read-only.");
19793 return 1;
19794 }
19795
19796
19797 static PyObject *_wrap_GREY_PEN_get(void) {
19798 PyObject *pyobj;
19799
19800 pyobj = SWIG_NewPointerObj((void *)(wxGREY_PEN), SWIGTYPE_p_wxPen, 0);
19801 return pyobj;
19802 }
19803
19804
19805 static int _wrap_MEDIUM_GREY_PEN_set(PyObject *) {
19806 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_PEN is read-only.");
19807 return 1;
19808 }
19809
19810
19811 static PyObject *_wrap_MEDIUM_GREY_PEN_get(void) {
19812 PyObject *pyobj;
19813
19814 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_PEN), SWIGTYPE_p_wxPen, 0);
19815 return pyobj;
19816 }
19817
19818
19819 static int _wrap_LIGHT_GREY_PEN_set(PyObject *) {
19820 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_PEN is read-only.");
19821 return 1;
19822 }
19823
19824
19825 static PyObject *_wrap_LIGHT_GREY_PEN_get(void) {
19826 PyObject *pyobj;
19827
19828 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_PEN), SWIGTYPE_p_wxPen, 0);
19829 return pyobj;
19830 }
19831
19832
19833 static int _wrap_BLUE_BRUSH_set(PyObject *) {
19834 PyErr_SetString(PyExc_TypeError,"Variable BLUE_BRUSH is read-only.");
19835 return 1;
19836 }
19837
19838
19839 static PyObject *_wrap_BLUE_BRUSH_get(void) {
19840 PyObject *pyobj;
19841
19842 pyobj = SWIG_NewPointerObj((void *)(wxBLUE_BRUSH), SWIGTYPE_p_wxBrush, 0);
19843 return pyobj;
19844 }
19845
19846
19847 static int _wrap_GREEN_BRUSH_set(PyObject *) {
19848 PyErr_SetString(PyExc_TypeError,"Variable GREEN_BRUSH is read-only.");
19849 return 1;
19850 }
19851
19852
19853 static PyObject *_wrap_GREEN_BRUSH_get(void) {
19854 PyObject *pyobj;
19855
19856 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_BRUSH), SWIGTYPE_p_wxBrush, 0);
19857 return pyobj;
19858 }
19859
19860
19861 static int _wrap_WHITE_BRUSH_set(PyObject *) {
19862 PyErr_SetString(PyExc_TypeError,"Variable WHITE_BRUSH is read-only.");
19863 return 1;
19864 }
19865
19866
19867 static PyObject *_wrap_WHITE_BRUSH_get(void) {
19868 PyObject *pyobj;
19869
19870 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_BRUSH), SWIGTYPE_p_wxBrush, 0);
19871 return pyobj;
19872 }
19873
19874
19875 static int _wrap_BLACK_BRUSH_set(PyObject *) {
19876 PyErr_SetString(PyExc_TypeError,"Variable BLACK_BRUSH is read-only.");
19877 return 1;
19878 }
19879
19880
19881 static PyObject *_wrap_BLACK_BRUSH_get(void) {
19882 PyObject *pyobj;
19883
19884 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_BRUSH), SWIGTYPE_p_wxBrush, 0);
19885 return pyobj;
19886 }
19887
19888
19889 static int _wrap_TRANSPARENT_BRUSH_set(PyObject *) {
19890 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_BRUSH is read-only.");
19891 return 1;
19892 }
19893
19894
19895 static PyObject *_wrap_TRANSPARENT_BRUSH_get(void) {
19896 PyObject *pyobj;
19897
19898 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_BRUSH), SWIGTYPE_p_wxBrush, 0);
19899 return pyobj;
19900 }
19901
19902
19903 static int _wrap_CYAN_BRUSH_set(PyObject *) {
19904 PyErr_SetString(PyExc_TypeError,"Variable CYAN_BRUSH is read-only.");
19905 return 1;
19906 }
19907
19908
19909 static PyObject *_wrap_CYAN_BRUSH_get(void) {
19910 PyObject *pyobj;
19911
19912 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_BRUSH), SWIGTYPE_p_wxBrush, 0);
19913 return pyobj;
19914 }
19915
19916
19917 static int _wrap_RED_BRUSH_set(PyObject *) {
19918 PyErr_SetString(PyExc_TypeError,"Variable RED_BRUSH is read-only.");
19919 return 1;
19920 }
19921
19922
19923 static PyObject *_wrap_RED_BRUSH_get(void) {
19924 PyObject *pyobj;
19925
19926 pyobj = SWIG_NewPointerObj((void *)(wxRED_BRUSH), SWIGTYPE_p_wxBrush, 0);
19927 return pyobj;
19928 }
19929
19930
19931 static int _wrap_GREY_BRUSH_set(PyObject *) {
19932 PyErr_SetString(PyExc_TypeError,"Variable GREY_BRUSH is read-only.");
19933 return 1;
19934 }
19935
19936
19937 static PyObject *_wrap_GREY_BRUSH_get(void) {
19938 PyObject *pyobj;
19939
19940 pyobj = SWIG_NewPointerObj((void *)(wxGREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19941 return pyobj;
19942 }
19943
19944
19945 static int _wrap_MEDIUM_GREY_BRUSH_set(PyObject *) {
19946 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_BRUSH is read-only.");
19947 return 1;
19948 }
19949
19950
19951 static PyObject *_wrap_MEDIUM_GREY_BRUSH_get(void) {
19952 PyObject *pyobj;
19953
19954 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19955 return pyobj;
19956 }
19957
19958
19959 static int _wrap_LIGHT_GREY_BRUSH_set(PyObject *) {
19960 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_BRUSH is read-only.");
19961 return 1;
19962 }
19963
19964
19965 static PyObject *_wrap_LIGHT_GREY_BRUSH_get(void) {
19966 PyObject *pyobj;
19967
19968 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19969 return pyobj;
19970 }
19971
19972
19973 static int _wrap_BLACK_set(PyObject *) {
19974 PyErr_SetString(PyExc_TypeError,"Variable BLACK is read-only.");
19975 return 1;
19976 }
19977
19978
19979 static PyObject *_wrap_BLACK_get(void) {
19980 PyObject *pyobj;
19981
19982 pyobj = SWIG_NewPointerObj((void *)(wxBLACK), SWIGTYPE_p_wxColour, 0);
19983 return pyobj;
19984 }
19985
19986
19987 static int _wrap_WHITE_set(PyObject *) {
19988 PyErr_SetString(PyExc_TypeError,"Variable WHITE is read-only.");
19989 return 1;
19990 }
19991
19992
19993 static PyObject *_wrap_WHITE_get(void) {
19994 PyObject *pyobj;
19995
19996 pyobj = SWIG_NewPointerObj((void *)(wxWHITE), SWIGTYPE_p_wxColour, 0);
19997 return pyobj;
19998 }
19999
20000
20001 static int _wrap_RED_set(PyObject *) {
20002 PyErr_SetString(PyExc_TypeError,"Variable RED is read-only.");
20003 return 1;
20004 }
20005
20006
20007 static PyObject *_wrap_RED_get(void) {
20008 PyObject *pyobj;
20009
20010 pyobj = SWIG_NewPointerObj((void *)(wxRED), SWIGTYPE_p_wxColour, 0);
20011 return pyobj;
20012 }
20013
20014
20015 static int _wrap_BLUE_set(PyObject *) {
20016 PyErr_SetString(PyExc_TypeError,"Variable BLUE is read-only.");
20017 return 1;
20018 }
20019
20020
20021 static PyObject *_wrap_BLUE_get(void) {
20022 PyObject *pyobj;
20023
20024 pyobj = SWIG_NewPointerObj((void *)(wxBLUE), SWIGTYPE_p_wxColour, 0);
20025 return pyobj;
20026 }
20027
20028
20029 static int _wrap_GREEN_set(PyObject *) {
20030 PyErr_SetString(PyExc_TypeError,"Variable GREEN is read-only.");
20031 return 1;
20032 }
20033
20034
20035 static PyObject *_wrap_GREEN_get(void) {
20036 PyObject *pyobj;
20037
20038 pyobj = SWIG_NewPointerObj((void *)(wxGREEN), SWIGTYPE_p_wxColour, 0);
20039 return pyobj;
20040 }
20041
20042
20043 static int _wrap_CYAN_set(PyObject *) {
20044 PyErr_SetString(PyExc_TypeError,"Variable CYAN is read-only.");
20045 return 1;
20046 }
20047
20048
20049 static PyObject *_wrap_CYAN_get(void) {
20050 PyObject *pyobj;
20051
20052 pyobj = SWIG_NewPointerObj((void *)(wxCYAN), SWIGTYPE_p_wxColour, 0);
20053 return pyobj;
20054 }
20055
20056
20057 static int _wrap_LIGHT_GREY_set(PyObject *) {
20058 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY is read-only.");
20059 return 1;
20060 }
20061
20062
20063 static PyObject *_wrap_LIGHT_GREY_get(void) {
20064 PyObject *pyobj;
20065
20066 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY), SWIGTYPE_p_wxColour, 0);
20067 return pyobj;
20068 }
20069
20070
20071 static int _wrap_STANDARD_CURSOR_set(PyObject *) {
20072 PyErr_SetString(PyExc_TypeError,"Variable STANDARD_CURSOR is read-only.");
20073 return 1;
20074 }
20075
20076
20077 static PyObject *_wrap_STANDARD_CURSOR_get(void) {
20078 PyObject *pyobj;
20079
20080 pyobj = SWIG_NewPointerObj((void *)(wxSTANDARD_CURSOR), SWIGTYPE_p_wxCursor, 0);
20081 return pyobj;
20082 }
20083
20084
20085 static int _wrap_HOURGLASS_CURSOR_set(PyObject *) {
20086 PyErr_SetString(PyExc_TypeError,"Variable HOURGLASS_CURSOR is read-only.");
20087 return 1;
20088 }
20089
20090
20091 static PyObject *_wrap_HOURGLASS_CURSOR_get(void) {
20092 PyObject *pyobj;
20093
20094 pyobj = SWIG_NewPointerObj((void *)(wxHOURGLASS_CURSOR), SWIGTYPE_p_wxCursor, 0);
20095 return pyobj;
20096 }
20097
20098
20099 static int _wrap_CROSS_CURSOR_set(PyObject *) {
20100 PyErr_SetString(PyExc_TypeError,"Variable CROSS_CURSOR is read-only.");
20101 return 1;
20102 }
20103
20104
20105 static PyObject *_wrap_CROSS_CURSOR_get(void) {
20106 PyObject *pyobj;
20107
20108 pyobj = SWIG_NewPointerObj((void *)(wxCROSS_CURSOR), SWIGTYPE_p_wxCursor, 0);
20109 return pyobj;
20110 }
20111
20112
20113 static int _wrap_NullBitmap_set(PyObject *) {
20114 PyErr_SetString(PyExc_TypeError,"Variable NullBitmap is read-only.");
20115 return 1;
20116 }
20117
20118
20119 static PyObject *_wrap_NullBitmap_get(void) {
20120 PyObject *pyobj;
20121
20122 pyobj = SWIG_NewPointerObj((void *)(&wxNullBitmap), SWIGTYPE_p_wxBitmap, 0);
20123 return pyobj;
20124 }
20125
20126
20127 static int _wrap_NullIcon_set(PyObject *) {
20128 PyErr_SetString(PyExc_TypeError,"Variable NullIcon is read-only.");
20129 return 1;
20130 }
20131
20132
20133 static PyObject *_wrap_NullIcon_get(void) {
20134 PyObject *pyobj;
20135
20136 pyobj = SWIG_NewPointerObj((void *)(&wxNullIcon), SWIGTYPE_p_wxIcon, 0);
20137 return pyobj;
20138 }
20139
20140
20141 static int _wrap_NullCursor_set(PyObject *) {
20142 PyErr_SetString(PyExc_TypeError,"Variable NullCursor is read-only.");
20143 return 1;
20144 }
20145
20146
20147 static PyObject *_wrap_NullCursor_get(void) {
20148 PyObject *pyobj;
20149
20150 pyobj = SWIG_NewPointerObj((void *)(&wxNullCursor), SWIGTYPE_p_wxCursor, 0);
20151 return pyobj;
20152 }
20153
20154
20155 static int _wrap_NullPen_set(PyObject *) {
20156 PyErr_SetString(PyExc_TypeError,"Variable NullPen is read-only.");
20157 return 1;
20158 }
20159
20160
20161 static PyObject *_wrap_NullPen_get(void) {
20162 PyObject *pyobj;
20163
20164 pyobj = SWIG_NewPointerObj((void *)(&wxNullPen), SWIGTYPE_p_wxPen, 0);
20165 return pyobj;
20166 }
20167
20168
20169 static int _wrap_NullBrush_set(PyObject *) {
20170 PyErr_SetString(PyExc_TypeError,"Variable NullBrush is read-only.");
20171 return 1;
20172 }
20173
20174
20175 static PyObject *_wrap_NullBrush_get(void) {
20176 PyObject *pyobj;
20177
20178 pyobj = SWIG_NewPointerObj((void *)(&wxNullBrush), SWIGTYPE_p_wxBrush, 0);
20179 return pyobj;
20180 }
20181
20182
20183 static int _wrap_NullPalette_set(PyObject *) {
20184 PyErr_SetString(PyExc_TypeError,"Variable NullPalette is read-only.");
20185 return 1;
20186 }
20187
20188
20189 static PyObject *_wrap_NullPalette_get(void) {
20190 PyObject *pyobj;
20191
20192 pyobj = SWIG_NewPointerObj((void *)(&wxNullPalette), SWIGTYPE_p_wxPalette, 0);
20193 return pyobj;
20194 }
20195
20196
20197 static int _wrap_NullFont_set(PyObject *) {
20198 PyErr_SetString(PyExc_TypeError,"Variable NullFont is read-only.");
20199 return 1;
20200 }
20201
20202
20203 static PyObject *_wrap_NullFont_get(void) {
20204 PyObject *pyobj;
20205
20206 pyobj = SWIG_NewPointerObj((void *)(&wxNullFont), SWIGTYPE_p_wxFont, 0);
20207 return pyobj;
20208 }
20209
20210
20211 static int _wrap_NullColour_set(PyObject *) {
20212 PyErr_SetString(PyExc_TypeError,"Variable NullColour is read-only.");
20213 return 1;
20214 }
20215
20216
20217 static PyObject *_wrap_NullColour_get(void) {
20218 PyObject *pyobj;
20219
20220 pyobj = SWIG_NewPointerObj((void *)(&wxNullColour), SWIGTYPE_p_wxColour, 0);
20221 return pyobj;
20222 }
20223
20224
20225 static PyObject *_wrap_PenList_AddPen(PyObject *, PyObject *args, PyObject *kwargs) {
20226 PyObject *resultobj;
20227 wxPenList *arg1 = (wxPenList *) 0 ;
20228 wxPen *arg2 = (wxPen *) 0 ;
20229 PyObject * obj0 = 0 ;
20230 PyObject * obj1 = 0 ;
20231 char *kwnames[] = {
20232 (char *) "self",(char *) "pen", NULL
20233 };
20234
20235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_AddPen",kwnames,&obj0,&obj1)) goto fail;
20236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
20237 if (SWIG_arg_fail(1)) SWIG_fail;
20238 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
20239 if (SWIG_arg_fail(2)) SWIG_fail;
20240 {
20241 PyThreadState* __tstate = wxPyBeginAllowThreads();
20242 (arg1)->AddPen(arg2);
20243
20244 wxPyEndAllowThreads(__tstate);
20245 if (PyErr_Occurred()) SWIG_fail;
20246 }
20247 Py_INCREF(Py_None); resultobj = Py_None;
20248 return resultobj;
20249 fail:
20250 return NULL;
20251 }
20252
20253
20254 static PyObject *_wrap_PenList_FindOrCreatePen(PyObject *, PyObject *args, PyObject *kwargs) {
20255 PyObject *resultobj;
20256 wxPenList *arg1 = (wxPenList *) 0 ;
20257 wxColour *arg2 = 0 ;
20258 int arg3 ;
20259 int arg4 ;
20260 wxPen *result;
20261 wxColour temp2 ;
20262 PyObject * obj0 = 0 ;
20263 PyObject * obj1 = 0 ;
20264 PyObject * obj2 = 0 ;
20265 PyObject * obj3 = 0 ;
20266 char *kwnames[] = {
20267 (char *) "self",(char *) "colour",(char *) "width",(char *) "style", NULL
20268 };
20269
20270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PenList_FindOrCreatePen",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
20272 if (SWIG_arg_fail(1)) SWIG_fail;
20273 {
20274 arg2 = &temp2;
20275 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20276 }
20277 {
20278 arg3 = (int)(SWIG_As_int(obj2));
20279 if (SWIG_arg_fail(3)) SWIG_fail;
20280 }
20281 {
20282 arg4 = (int)(SWIG_As_int(obj3));
20283 if (SWIG_arg_fail(4)) SWIG_fail;
20284 }
20285 {
20286 PyThreadState* __tstate = wxPyBeginAllowThreads();
20287 result = (wxPen *)(arg1)->FindOrCreatePen((wxColour const &)*arg2,arg3,arg4);
20288
20289 wxPyEndAllowThreads(__tstate);
20290 if (PyErr_Occurred()) SWIG_fail;
20291 }
20292 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 0);
20293 return resultobj;
20294 fail:
20295 return NULL;
20296 }
20297
20298
20299 static PyObject *_wrap_PenList_RemovePen(PyObject *, PyObject *args, PyObject *kwargs) {
20300 PyObject *resultobj;
20301 wxPenList *arg1 = (wxPenList *) 0 ;
20302 wxPen *arg2 = (wxPen *) 0 ;
20303 PyObject * obj0 = 0 ;
20304 PyObject * obj1 = 0 ;
20305 char *kwnames[] = {
20306 (char *) "self",(char *) "pen", NULL
20307 };
20308
20309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_RemovePen",kwnames,&obj0,&obj1)) goto fail;
20310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
20311 if (SWIG_arg_fail(1)) SWIG_fail;
20312 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
20313 if (SWIG_arg_fail(2)) SWIG_fail;
20314 {
20315 PyThreadState* __tstate = wxPyBeginAllowThreads();
20316 (arg1)->RemovePen(arg2);
20317
20318 wxPyEndAllowThreads(__tstate);
20319 if (PyErr_Occurred()) SWIG_fail;
20320 }
20321 Py_INCREF(Py_None); resultobj = Py_None;
20322 return resultobj;
20323 fail:
20324 return NULL;
20325 }
20326
20327
20328 static PyObject *_wrap_PenList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
20329 PyObject *resultobj;
20330 wxPenList *arg1 = (wxPenList *) 0 ;
20331 int result;
20332 PyObject * obj0 = 0 ;
20333 char *kwnames[] = {
20334 (char *) "self", NULL
20335 };
20336
20337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PenList_GetCount",kwnames,&obj0)) goto fail;
20338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
20339 if (SWIG_arg_fail(1)) SWIG_fail;
20340 {
20341 PyThreadState* __tstate = wxPyBeginAllowThreads();
20342 result = (int)(arg1)->GetCount();
20343
20344 wxPyEndAllowThreads(__tstate);
20345 if (PyErr_Occurred()) SWIG_fail;
20346 }
20347 {
20348 resultobj = SWIG_From_int((int)(result));
20349 }
20350 return resultobj;
20351 fail:
20352 return NULL;
20353 }
20354
20355
20356 static PyObject * PenList_swigregister(PyObject *, PyObject *args) {
20357 PyObject *obj;
20358 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20359 SWIG_TypeClientData(SWIGTYPE_p_wxPenList, obj);
20360 Py_INCREF(obj);
20361 return Py_BuildValue((char *)"");
20362 }
20363 static PyObject *_wrap_BrushList_AddBrush(PyObject *, PyObject *args, PyObject *kwargs) {
20364 PyObject *resultobj;
20365 wxBrushList *arg1 = (wxBrushList *) 0 ;
20366 wxBrush *arg2 = (wxBrush *) 0 ;
20367 PyObject * obj0 = 0 ;
20368 PyObject * obj1 = 0 ;
20369 char *kwnames[] = {
20370 (char *) "self",(char *) "brush", NULL
20371 };
20372
20373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_AddBrush",kwnames,&obj0,&obj1)) goto fail;
20374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
20375 if (SWIG_arg_fail(1)) SWIG_fail;
20376 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
20377 if (SWIG_arg_fail(2)) SWIG_fail;
20378 {
20379 PyThreadState* __tstate = wxPyBeginAllowThreads();
20380 (arg1)->AddBrush(arg2);
20381
20382 wxPyEndAllowThreads(__tstate);
20383 if (PyErr_Occurred()) SWIG_fail;
20384 }
20385 Py_INCREF(Py_None); resultobj = Py_None;
20386 return resultobj;
20387 fail:
20388 return NULL;
20389 }
20390
20391
20392 static PyObject *_wrap_BrushList_FindOrCreateBrush(PyObject *, PyObject *args, PyObject *kwargs) {
20393 PyObject *resultobj;
20394 wxBrushList *arg1 = (wxBrushList *) 0 ;
20395 wxColour *arg2 = 0 ;
20396 int arg3 = (int) wxSOLID ;
20397 wxBrush *result;
20398 wxColour temp2 ;
20399 PyObject * obj0 = 0 ;
20400 PyObject * obj1 = 0 ;
20401 PyObject * obj2 = 0 ;
20402 char *kwnames[] = {
20403 (char *) "self",(char *) "colour",(char *) "style", NULL
20404 };
20405
20406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:BrushList_FindOrCreateBrush",kwnames,&obj0,&obj1,&obj2)) goto fail;
20407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
20408 if (SWIG_arg_fail(1)) SWIG_fail;
20409 {
20410 arg2 = &temp2;
20411 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20412 }
20413 if (obj2) {
20414 {
20415 arg3 = (int)(SWIG_As_int(obj2));
20416 if (SWIG_arg_fail(3)) SWIG_fail;
20417 }
20418 }
20419 {
20420 PyThreadState* __tstate = wxPyBeginAllowThreads();
20421 result = (wxBrush *)(arg1)->FindOrCreateBrush((wxColour const &)*arg2,arg3);
20422
20423 wxPyEndAllowThreads(__tstate);
20424 if (PyErr_Occurred()) SWIG_fail;
20425 }
20426 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 0);
20427 return resultobj;
20428 fail:
20429 return NULL;
20430 }
20431
20432
20433 static PyObject *_wrap_BrushList_RemoveBrush(PyObject *, PyObject *args, PyObject *kwargs) {
20434 PyObject *resultobj;
20435 wxBrushList *arg1 = (wxBrushList *) 0 ;
20436 wxBrush *arg2 = (wxBrush *) 0 ;
20437 PyObject * obj0 = 0 ;
20438 PyObject * obj1 = 0 ;
20439 char *kwnames[] = {
20440 (char *) "self",(char *) "brush", NULL
20441 };
20442
20443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_RemoveBrush",kwnames,&obj0,&obj1)) goto fail;
20444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
20445 if (SWIG_arg_fail(1)) SWIG_fail;
20446 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
20447 if (SWIG_arg_fail(2)) SWIG_fail;
20448 {
20449 PyThreadState* __tstate = wxPyBeginAllowThreads();
20450 (arg1)->RemoveBrush(arg2);
20451
20452 wxPyEndAllowThreads(__tstate);
20453 if (PyErr_Occurred()) SWIG_fail;
20454 }
20455 Py_INCREF(Py_None); resultobj = Py_None;
20456 return resultobj;
20457 fail:
20458 return NULL;
20459 }
20460
20461
20462 static PyObject *_wrap_BrushList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
20463 PyObject *resultobj;
20464 wxBrushList *arg1 = (wxBrushList *) 0 ;
20465 int result;
20466 PyObject * obj0 = 0 ;
20467 char *kwnames[] = {
20468 (char *) "self", NULL
20469 };
20470
20471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BrushList_GetCount",kwnames,&obj0)) goto fail;
20472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
20473 if (SWIG_arg_fail(1)) SWIG_fail;
20474 {
20475 PyThreadState* __tstate = wxPyBeginAllowThreads();
20476 result = (int)(arg1)->GetCount();
20477
20478 wxPyEndAllowThreads(__tstate);
20479 if (PyErr_Occurred()) SWIG_fail;
20480 }
20481 {
20482 resultobj = SWIG_From_int((int)(result));
20483 }
20484 return resultobj;
20485 fail:
20486 return NULL;
20487 }
20488
20489
20490 static PyObject * BrushList_swigregister(PyObject *, PyObject *args) {
20491 PyObject *obj;
20492 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20493 SWIG_TypeClientData(SWIGTYPE_p_wxBrushList, obj);
20494 Py_INCREF(obj);
20495 return Py_BuildValue((char *)"");
20496 }
20497 static PyObject *_wrap_new_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
20498 PyObject *resultobj;
20499 wxColourDatabase *result;
20500 char *kwnames[] = {
20501 NULL
20502 };
20503
20504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ColourDatabase",kwnames)) goto fail;
20505 {
20506 if (!wxPyCheckForApp()) SWIG_fail;
20507 PyThreadState* __tstate = wxPyBeginAllowThreads();
20508 result = (wxColourDatabase *)new wxColourDatabase();
20509
20510 wxPyEndAllowThreads(__tstate);
20511 if (PyErr_Occurred()) SWIG_fail;
20512 }
20513 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourDatabase, 1);
20514 return resultobj;
20515 fail:
20516 return NULL;
20517 }
20518
20519
20520 static PyObject *_wrap_delete_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
20521 PyObject *resultobj;
20522 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20523 PyObject * obj0 = 0 ;
20524 char *kwnames[] = {
20525 (char *) "self", NULL
20526 };
20527
20528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ColourDatabase",kwnames,&obj0)) goto fail;
20529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20530 if (SWIG_arg_fail(1)) SWIG_fail;
20531 {
20532 PyThreadState* __tstate = wxPyBeginAllowThreads();
20533 delete arg1;
20534
20535 wxPyEndAllowThreads(__tstate);
20536 if (PyErr_Occurred()) SWIG_fail;
20537 }
20538 Py_INCREF(Py_None); resultobj = Py_None;
20539 return resultobj;
20540 fail:
20541 return NULL;
20542 }
20543
20544
20545 static PyObject *_wrap_ColourDatabase_Find(PyObject *, PyObject *args, PyObject *kwargs) {
20546 PyObject *resultobj;
20547 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20548 wxString *arg2 = 0 ;
20549 wxColour result;
20550 bool temp2 = false ;
20551 PyObject * obj0 = 0 ;
20552 PyObject * obj1 = 0 ;
20553 char *kwnames[] = {
20554 (char *) "self",(char *) "name", NULL
20555 };
20556
20557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_Find",kwnames,&obj0,&obj1)) goto fail;
20558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20559 if (SWIG_arg_fail(1)) SWIG_fail;
20560 {
20561 arg2 = wxString_in_helper(obj1);
20562 if (arg2 == NULL) SWIG_fail;
20563 temp2 = true;
20564 }
20565 {
20566 PyThreadState* __tstate = wxPyBeginAllowThreads();
20567 result = ((wxColourDatabase const *)arg1)->Find((wxString const &)*arg2);
20568
20569 wxPyEndAllowThreads(__tstate);
20570 if (PyErr_Occurred()) SWIG_fail;
20571 }
20572 {
20573 wxColour * resultptr;
20574 resultptr = new wxColour((wxColour &)(result));
20575 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20576 }
20577 {
20578 if (temp2)
20579 delete arg2;
20580 }
20581 return resultobj;
20582 fail:
20583 {
20584 if (temp2)
20585 delete arg2;
20586 }
20587 return NULL;
20588 }
20589
20590
20591 static PyObject *_wrap_ColourDatabase_FindName(PyObject *, PyObject *args, PyObject *kwargs) {
20592 PyObject *resultobj;
20593 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20594 wxColour *arg2 = 0 ;
20595 wxString result;
20596 wxColour temp2 ;
20597 PyObject * obj0 = 0 ;
20598 PyObject * obj1 = 0 ;
20599 char *kwnames[] = {
20600 (char *) "self",(char *) "colour", NULL
20601 };
20602
20603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_FindName",kwnames,&obj0,&obj1)) goto fail;
20604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20605 if (SWIG_arg_fail(1)) SWIG_fail;
20606 {
20607 arg2 = &temp2;
20608 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20609 }
20610 {
20611 PyThreadState* __tstate = wxPyBeginAllowThreads();
20612 result = ((wxColourDatabase const *)arg1)->FindName((wxColour const &)*arg2);
20613
20614 wxPyEndAllowThreads(__tstate);
20615 if (PyErr_Occurred()) SWIG_fail;
20616 }
20617 {
20618 #if wxUSE_UNICODE
20619 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20620 #else
20621 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20622 #endif
20623 }
20624 return resultobj;
20625 fail:
20626 return NULL;
20627 }
20628
20629
20630 static PyObject *_wrap_ColourDatabase_AddColour(PyObject *, PyObject *args, PyObject *kwargs) {
20631 PyObject *resultobj;
20632 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20633 wxString *arg2 = 0 ;
20634 wxColour *arg3 = 0 ;
20635 bool temp2 = false ;
20636 wxColour temp3 ;
20637 PyObject * obj0 = 0 ;
20638 PyObject * obj1 = 0 ;
20639 PyObject * obj2 = 0 ;
20640 char *kwnames[] = {
20641 (char *) "self",(char *) "name",(char *) "colour", NULL
20642 };
20643
20644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ColourDatabase_AddColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
20645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20646 if (SWIG_arg_fail(1)) SWIG_fail;
20647 {
20648 arg2 = wxString_in_helper(obj1);
20649 if (arg2 == NULL) SWIG_fail;
20650 temp2 = true;
20651 }
20652 {
20653 arg3 = &temp3;
20654 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
20655 }
20656 {
20657 PyThreadState* __tstate = wxPyBeginAllowThreads();
20658 (arg1)->AddColour((wxString const &)*arg2,(wxColour const &)*arg3);
20659
20660 wxPyEndAllowThreads(__tstate);
20661 if (PyErr_Occurred()) SWIG_fail;
20662 }
20663 Py_INCREF(Py_None); resultobj = Py_None;
20664 {
20665 if (temp2)
20666 delete arg2;
20667 }
20668 return resultobj;
20669 fail:
20670 {
20671 if (temp2)
20672 delete arg2;
20673 }
20674 return NULL;
20675 }
20676
20677
20678 static PyObject *_wrap_ColourDatabase_Append(PyObject *, PyObject *args, PyObject *kwargs) {
20679 PyObject *resultobj;
20680 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20681 wxString *arg2 = 0 ;
20682 int arg3 ;
20683 int arg4 ;
20684 int arg5 ;
20685 bool temp2 = false ;
20686 PyObject * obj0 = 0 ;
20687 PyObject * obj1 = 0 ;
20688 PyObject * obj2 = 0 ;
20689 PyObject * obj3 = 0 ;
20690 PyObject * obj4 = 0 ;
20691 char *kwnames[] = {
20692 (char *) "self",(char *) "name",(char *) "red",(char *) "green",(char *) "blue", NULL
20693 };
20694
20695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:ColourDatabase_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20697 if (SWIG_arg_fail(1)) SWIG_fail;
20698 {
20699 arg2 = wxString_in_helper(obj1);
20700 if (arg2 == NULL) SWIG_fail;
20701 temp2 = true;
20702 }
20703 {
20704 arg3 = (int)(SWIG_As_int(obj2));
20705 if (SWIG_arg_fail(3)) SWIG_fail;
20706 }
20707 {
20708 arg4 = (int)(SWIG_As_int(obj3));
20709 if (SWIG_arg_fail(4)) SWIG_fail;
20710 }
20711 {
20712 arg5 = (int)(SWIG_As_int(obj4));
20713 if (SWIG_arg_fail(5)) SWIG_fail;
20714 }
20715 {
20716 PyThreadState* __tstate = wxPyBeginAllowThreads();
20717 wxColourDatabase_Append(arg1,(wxString const &)*arg2,arg3,arg4,arg5);
20718
20719 wxPyEndAllowThreads(__tstate);
20720 if (PyErr_Occurred()) SWIG_fail;
20721 }
20722 Py_INCREF(Py_None); resultobj = Py_None;
20723 {
20724 if (temp2)
20725 delete arg2;
20726 }
20727 return resultobj;
20728 fail:
20729 {
20730 if (temp2)
20731 delete arg2;
20732 }
20733 return NULL;
20734 }
20735
20736
20737 static PyObject * ColourDatabase_swigregister(PyObject *, PyObject *args) {
20738 PyObject *obj;
20739 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20740 SWIG_TypeClientData(SWIGTYPE_p_wxColourDatabase, obj);
20741 Py_INCREF(obj);
20742 return Py_BuildValue((char *)"");
20743 }
20744 static PyObject *_wrap_FontList_AddFont(PyObject *, PyObject *args, PyObject *kwargs) {
20745 PyObject *resultobj;
20746 wxFontList *arg1 = (wxFontList *) 0 ;
20747 wxFont *arg2 = (wxFont *) 0 ;
20748 PyObject * obj0 = 0 ;
20749 PyObject * obj1 = 0 ;
20750 char *kwnames[] = {
20751 (char *) "self",(char *) "font", NULL
20752 };
20753
20754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_AddFont",kwnames,&obj0,&obj1)) goto fail;
20755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20756 if (SWIG_arg_fail(1)) SWIG_fail;
20757 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
20758 if (SWIG_arg_fail(2)) SWIG_fail;
20759 {
20760 PyThreadState* __tstate = wxPyBeginAllowThreads();
20761 (arg1)->AddFont(arg2);
20762
20763 wxPyEndAllowThreads(__tstate);
20764 if (PyErr_Occurred()) SWIG_fail;
20765 }
20766 Py_INCREF(Py_None); resultobj = Py_None;
20767 return resultobj;
20768 fail:
20769 return NULL;
20770 }
20771
20772
20773 static PyObject *_wrap_FontList_FindOrCreateFont(PyObject *, PyObject *args, PyObject *kwargs) {
20774 PyObject *resultobj;
20775 wxFontList *arg1 = (wxFontList *) 0 ;
20776 int arg2 ;
20777 int arg3 ;
20778 int arg4 ;
20779 int arg5 ;
20780 bool arg6 = (bool) false ;
20781 wxString const &arg7_defvalue = wxPyEmptyString ;
20782 wxString *arg7 = (wxString *) &arg7_defvalue ;
20783 wxFontEncoding arg8 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
20784 wxFont *result;
20785 bool temp7 = false ;
20786 PyObject * obj0 = 0 ;
20787 PyObject * obj1 = 0 ;
20788 PyObject * obj2 = 0 ;
20789 PyObject * obj3 = 0 ;
20790 PyObject * obj4 = 0 ;
20791 PyObject * obj5 = 0 ;
20792 PyObject * obj6 = 0 ;
20793 PyObject * obj7 = 0 ;
20794 char *kwnames[] = {
20795 (char *) "self",(char *) "point_size",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "facename",(char *) "encoding", NULL
20796 };
20797
20798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:FontList_FindOrCreateFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20800 if (SWIG_arg_fail(1)) SWIG_fail;
20801 {
20802 arg2 = (int)(SWIG_As_int(obj1));
20803 if (SWIG_arg_fail(2)) SWIG_fail;
20804 }
20805 {
20806 arg3 = (int)(SWIG_As_int(obj2));
20807 if (SWIG_arg_fail(3)) SWIG_fail;
20808 }
20809 {
20810 arg4 = (int)(SWIG_As_int(obj3));
20811 if (SWIG_arg_fail(4)) SWIG_fail;
20812 }
20813 {
20814 arg5 = (int)(SWIG_As_int(obj4));
20815 if (SWIG_arg_fail(5)) SWIG_fail;
20816 }
20817 if (obj5) {
20818 {
20819 arg6 = (bool)(SWIG_As_bool(obj5));
20820 if (SWIG_arg_fail(6)) SWIG_fail;
20821 }
20822 }
20823 if (obj6) {
20824 {
20825 arg7 = wxString_in_helper(obj6);
20826 if (arg7 == NULL) SWIG_fail;
20827 temp7 = true;
20828 }
20829 }
20830 if (obj7) {
20831 {
20832 arg8 = (wxFontEncoding)(SWIG_As_int(obj7));
20833 if (SWIG_arg_fail(8)) SWIG_fail;
20834 }
20835 }
20836 {
20837 PyThreadState* __tstate = wxPyBeginAllowThreads();
20838 result = (wxFont *)(arg1)->FindOrCreateFont(arg2,arg3,arg4,arg5,arg6,(wxString const &)*arg7,(wxFontEncoding )arg8);
20839
20840 wxPyEndAllowThreads(__tstate);
20841 if (PyErr_Occurred()) SWIG_fail;
20842 }
20843 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
20844 {
20845 if (temp7)
20846 delete arg7;
20847 }
20848 return resultobj;
20849 fail:
20850 {
20851 if (temp7)
20852 delete arg7;
20853 }
20854 return NULL;
20855 }
20856
20857
20858 static PyObject *_wrap_FontList_RemoveFont(PyObject *, PyObject *args, PyObject *kwargs) {
20859 PyObject *resultobj;
20860 wxFontList *arg1 = (wxFontList *) 0 ;
20861 wxFont *arg2 = (wxFont *) 0 ;
20862 PyObject * obj0 = 0 ;
20863 PyObject * obj1 = 0 ;
20864 char *kwnames[] = {
20865 (char *) "self",(char *) "font", NULL
20866 };
20867
20868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_RemoveFont",kwnames,&obj0,&obj1)) goto fail;
20869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20870 if (SWIG_arg_fail(1)) SWIG_fail;
20871 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
20872 if (SWIG_arg_fail(2)) SWIG_fail;
20873 {
20874 PyThreadState* __tstate = wxPyBeginAllowThreads();
20875 (arg1)->RemoveFont(arg2);
20876
20877 wxPyEndAllowThreads(__tstate);
20878 if (PyErr_Occurred()) SWIG_fail;
20879 }
20880 Py_INCREF(Py_None); resultobj = Py_None;
20881 return resultobj;
20882 fail:
20883 return NULL;
20884 }
20885
20886
20887 static PyObject *_wrap_FontList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
20888 PyObject *resultobj;
20889 wxFontList *arg1 = (wxFontList *) 0 ;
20890 int result;
20891 PyObject * obj0 = 0 ;
20892 char *kwnames[] = {
20893 (char *) "self", NULL
20894 };
20895
20896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontList_GetCount",kwnames,&obj0)) goto fail;
20897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20898 if (SWIG_arg_fail(1)) SWIG_fail;
20899 {
20900 PyThreadState* __tstate = wxPyBeginAllowThreads();
20901 result = (int)(arg1)->GetCount();
20902
20903 wxPyEndAllowThreads(__tstate);
20904 if (PyErr_Occurred()) SWIG_fail;
20905 }
20906 {
20907 resultobj = SWIG_From_int((int)(result));
20908 }
20909 return resultobj;
20910 fail:
20911 return NULL;
20912 }
20913
20914
20915 static PyObject * FontList_swigregister(PyObject *, PyObject *args) {
20916 PyObject *obj;
20917 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20918 SWIG_TypeClientData(SWIGTYPE_p_wxFontList, obj);
20919 Py_INCREF(obj);
20920 return Py_BuildValue((char *)"");
20921 }
20922 static int _wrap_TheFontList_set(PyObject *) {
20923 PyErr_SetString(PyExc_TypeError,"Variable TheFontList is read-only.");
20924 return 1;
20925 }
20926
20927
20928 static PyObject *_wrap_TheFontList_get(void) {
20929 PyObject *pyobj;
20930
20931 pyobj = SWIG_NewPointerObj((void *)(wxTheFontList), SWIGTYPE_p_wxFontList, 0);
20932 return pyobj;
20933 }
20934
20935
20936 static int _wrap_ThePenList_set(PyObject *) {
20937 PyErr_SetString(PyExc_TypeError,"Variable ThePenList is read-only.");
20938 return 1;
20939 }
20940
20941
20942 static PyObject *_wrap_ThePenList_get(void) {
20943 PyObject *pyobj;
20944
20945 pyobj = SWIG_NewPointerObj((void *)(wxThePenList), SWIGTYPE_p_wxPenList, 0);
20946 return pyobj;
20947 }
20948
20949
20950 static int _wrap_TheBrushList_set(PyObject *) {
20951 PyErr_SetString(PyExc_TypeError,"Variable TheBrushList is read-only.");
20952 return 1;
20953 }
20954
20955
20956 static PyObject *_wrap_TheBrushList_get(void) {
20957 PyObject *pyobj;
20958
20959 pyobj = SWIG_NewPointerObj((void *)(wxTheBrushList), SWIGTYPE_p_wxBrushList, 0);
20960 return pyobj;
20961 }
20962
20963
20964 static int _wrap_TheColourDatabase_set(PyObject *) {
20965 PyErr_SetString(PyExc_TypeError,"Variable TheColourDatabase is read-only.");
20966 return 1;
20967 }
20968
20969
20970 static PyObject *_wrap_TheColourDatabase_get(void) {
20971 PyObject *pyobj;
20972
20973 pyobj = SWIG_NewPointerObj((void *)(wxTheColourDatabase), SWIGTYPE_p_wxColourDatabase, 0);
20974 return pyobj;
20975 }
20976
20977
20978 static PyObject *_wrap_new_Effects(PyObject *, PyObject *args, PyObject *kwargs) {
20979 PyObject *resultobj;
20980 wxEffects *result;
20981 char *kwnames[] = {
20982 NULL
20983 };
20984
20985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Effects",kwnames)) goto fail;
20986 {
20987 PyThreadState* __tstate = wxPyBeginAllowThreads();
20988 result = (wxEffects *)new wxEffects();
20989
20990 wxPyEndAllowThreads(__tstate);
20991 if (PyErr_Occurred()) SWIG_fail;
20992 }
20993 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEffects, 1);
20994 return resultobj;
20995 fail:
20996 return NULL;
20997 }
20998
20999
21000 static PyObject *_wrap_Effects_GetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
21001 PyObject *resultobj;
21002 wxEffects *arg1 = (wxEffects *) 0 ;
21003 wxColour result;
21004 PyObject * obj0 = 0 ;
21005 char *kwnames[] = {
21006 (char *) "self", NULL
21007 };
21008
21009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetHighlightColour",kwnames,&obj0)) goto fail;
21010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21011 if (SWIG_arg_fail(1)) SWIG_fail;
21012 {
21013 PyThreadState* __tstate = wxPyBeginAllowThreads();
21014 result = ((wxEffects const *)arg1)->GetHighlightColour();
21015
21016 wxPyEndAllowThreads(__tstate);
21017 if (PyErr_Occurred()) SWIG_fail;
21018 }
21019 {
21020 wxColour * resultptr;
21021 resultptr = new wxColour((wxColour &)(result));
21022 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
21023 }
21024 return resultobj;
21025 fail:
21026 return NULL;
21027 }
21028
21029
21030 static PyObject *_wrap_Effects_GetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21031 PyObject *resultobj;
21032 wxEffects *arg1 = (wxEffects *) 0 ;
21033 wxColour result;
21034 PyObject * obj0 = 0 ;
21035 char *kwnames[] = {
21036 (char *) "self", NULL
21037 };
21038
21039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetLightShadow",kwnames,&obj0)) goto fail;
21040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21041 if (SWIG_arg_fail(1)) SWIG_fail;
21042 {
21043 PyThreadState* __tstate = wxPyBeginAllowThreads();
21044 result = ((wxEffects const *)arg1)->GetLightShadow();
21045
21046 wxPyEndAllowThreads(__tstate);
21047 if (PyErr_Occurred()) SWIG_fail;
21048 }
21049 {
21050 wxColour * resultptr;
21051 resultptr = new wxColour((wxColour &)(result));
21052 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
21053 }
21054 return resultobj;
21055 fail:
21056 return NULL;
21057 }
21058
21059
21060 static PyObject *_wrap_Effects_GetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
21061 PyObject *resultobj;
21062 wxEffects *arg1 = (wxEffects *) 0 ;
21063 wxColour result;
21064 PyObject * obj0 = 0 ;
21065 char *kwnames[] = {
21066 (char *) "self", NULL
21067 };
21068
21069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetFaceColour",kwnames,&obj0)) goto fail;
21070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21071 if (SWIG_arg_fail(1)) SWIG_fail;
21072 {
21073 PyThreadState* __tstate = wxPyBeginAllowThreads();
21074 result = ((wxEffects const *)arg1)->GetFaceColour();
21075
21076 wxPyEndAllowThreads(__tstate);
21077 if (PyErr_Occurred()) SWIG_fail;
21078 }
21079 {
21080 wxColour * resultptr;
21081 resultptr = new wxColour((wxColour &)(result));
21082 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
21083 }
21084 return resultobj;
21085 fail:
21086 return NULL;
21087 }
21088
21089
21090 static PyObject *_wrap_Effects_GetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21091 PyObject *resultobj;
21092 wxEffects *arg1 = (wxEffects *) 0 ;
21093 wxColour result;
21094 PyObject * obj0 = 0 ;
21095 char *kwnames[] = {
21096 (char *) "self", NULL
21097 };
21098
21099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetMediumShadow",kwnames,&obj0)) goto fail;
21100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21101 if (SWIG_arg_fail(1)) SWIG_fail;
21102 {
21103 PyThreadState* __tstate = wxPyBeginAllowThreads();
21104 result = ((wxEffects const *)arg1)->GetMediumShadow();
21105
21106 wxPyEndAllowThreads(__tstate);
21107 if (PyErr_Occurred()) SWIG_fail;
21108 }
21109 {
21110 wxColour * resultptr;
21111 resultptr = new wxColour((wxColour &)(result));
21112 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
21113 }
21114 return resultobj;
21115 fail:
21116 return NULL;
21117 }
21118
21119
21120 static PyObject *_wrap_Effects_GetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21121 PyObject *resultobj;
21122 wxEffects *arg1 = (wxEffects *) 0 ;
21123 wxColour result;
21124 PyObject * obj0 = 0 ;
21125 char *kwnames[] = {
21126 (char *) "self", NULL
21127 };
21128
21129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetDarkShadow",kwnames,&obj0)) goto fail;
21130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21131 if (SWIG_arg_fail(1)) SWIG_fail;
21132 {
21133 PyThreadState* __tstate = wxPyBeginAllowThreads();
21134 result = ((wxEffects const *)arg1)->GetDarkShadow();
21135
21136 wxPyEndAllowThreads(__tstate);
21137 if (PyErr_Occurred()) SWIG_fail;
21138 }
21139 {
21140 wxColour * resultptr;
21141 resultptr = new wxColour((wxColour &)(result));
21142 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
21143 }
21144 return resultobj;
21145 fail:
21146 return NULL;
21147 }
21148
21149
21150 static PyObject *_wrap_Effects_SetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
21151 PyObject *resultobj;
21152 wxEffects *arg1 = (wxEffects *) 0 ;
21153 wxColour *arg2 = 0 ;
21154 wxColour temp2 ;
21155 PyObject * obj0 = 0 ;
21156 PyObject * obj1 = 0 ;
21157 char *kwnames[] = {
21158 (char *) "self",(char *) "c", NULL
21159 };
21160
21161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetHighlightColour",kwnames,&obj0,&obj1)) goto fail;
21162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21163 if (SWIG_arg_fail(1)) SWIG_fail;
21164 {
21165 arg2 = &temp2;
21166 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21167 }
21168 {
21169 PyThreadState* __tstate = wxPyBeginAllowThreads();
21170 (arg1)->SetHighlightColour((wxColour const &)*arg2);
21171
21172 wxPyEndAllowThreads(__tstate);
21173 if (PyErr_Occurred()) SWIG_fail;
21174 }
21175 Py_INCREF(Py_None); resultobj = Py_None;
21176 return resultobj;
21177 fail:
21178 return NULL;
21179 }
21180
21181
21182 static PyObject *_wrap_Effects_SetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21183 PyObject *resultobj;
21184 wxEffects *arg1 = (wxEffects *) 0 ;
21185 wxColour *arg2 = 0 ;
21186 wxColour temp2 ;
21187 PyObject * obj0 = 0 ;
21188 PyObject * obj1 = 0 ;
21189 char *kwnames[] = {
21190 (char *) "self",(char *) "c", NULL
21191 };
21192
21193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetLightShadow",kwnames,&obj0,&obj1)) goto fail;
21194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21195 if (SWIG_arg_fail(1)) SWIG_fail;
21196 {
21197 arg2 = &temp2;
21198 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21199 }
21200 {
21201 PyThreadState* __tstate = wxPyBeginAllowThreads();
21202 (arg1)->SetLightShadow((wxColour const &)*arg2);
21203
21204 wxPyEndAllowThreads(__tstate);
21205 if (PyErr_Occurred()) SWIG_fail;
21206 }
21207 Py_INCREF(Py_None); resultobj = Py_None;
21208 return resultobj;
21209 fail:
21210 return NULL;
21211 }
21212
21213
21214 static PyObject *_wrap_Effects_SetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
21215 PyObject *resultobj;
21216 wxEffects *arg1 = (wxEffects *) 0 ;
21217 wxColour *arg2 = 0 ;
21218 wxColour temp2 ;
21219 PyObject * obj0 = 0 ;
21220 PyObject * obj1 = 0 ;
21221 char *kwnames[] = {
21222 (char *) "self",(char *) "c", NULL
21223 };
21224
21225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetFaceColour",kwnames,&obj0,&obj1)) goto fail;
21226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21227 if (SWIG_arg_fail(1)) SWIG_fail;
21228 {
21229 arg2 = &temp2;
21230 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21231 }
21232 {
21233 PyThreadState* __tstate = wxPyBeginAllowThreads();
21234 (arg1)->SetFaceColour((wxColour const &)*arg2);
21235
21236 wxPyEndAllowThreads(__tstate);
21237 if (PyErr_Occurred()) SWIG_fail;
21238 }
21239 Py_INCREF(Py_None); resultobj = Py_None;
21240 return resultobj;
21241 fail:
21242 return NULL;
21243 }
21244
21245
21246 static PyObject *_wrap_Effects_SetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21247 PyObject *resultobj;
21248 wxEffects *arg1 = (wxEffects *) 0 ;
21249 wxColour *arg2 = 0 ;
21250 wxColour temp2 ;
21251 PyObject * obj0 = 0 ;
21252 PyObject * obj1 = 0 ;
21253 char *kwnames[] = {
21254 (char *) "self",(char *) "c", NULL
21255 };
21256
21257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetMediumShadow",kwnames,&obj0,&obj1)) goto fail;
21258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21259 if (SWIG_arg_fail(1)) SWIG_fail;
21260 {
21261 arg2 = &temp2;
21262 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21263 }
21264 {
21265 PyThreadState* __tstate = wxPyBeginAllowThreads();
21266 (arg1)->SetMediumShadow((wxColour const &)*arg2);
21267
21268 wxPyEndAllowThreads(__tstate);
21269 if (PyErr_Occurred()) SWIG_fail;
21270 }
21271 Py_INCREF(Py_None); resultobj = Py_None;
21272 return resultobj;
21273 fail:
21274 return NULL;
21275 }
21276
21277
21278 static PyObject *_wrap_Effects_SetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21279 PyObject *resultobj;
21280 wxEffects *arg1 = (wxEffects *) 0 ;
21281 wxColour *arg2 = 0 ;
21282 wxColour temp2 ;
21283 PyObject * obj0 = 0 ;
21284 PyObject * obj1 = 0 ;
21285 char *kwnames[] = {
21286 (char *) "self",(char *) "c", NULL
21287 };
21288
21289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetDarkShadow",kwnames,&obj0,&obj1)) goto fail;
21290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21291 if (SWIG_arg_fail(1)) SWIG_fail;
21292 {
21293 arg2 = &temp2;
21294 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21295 }
21296 {
21297 PyThreadState* __tstate = wxPyBeginAllowThreads();
21298 (arg1)->SetDarkShadow((wxColour const &)*arg2);
21299
21300 wxPyEndAllowThreads(__tstate);
21301 if (PyErr_Occurred()) SWIG_fail;
21302 }
21303 Py_INCREF(Py_None); resultobj = Py_None;
21304 return resultobj;
21305 fail:
21306 return NULL;
21307 }
21308
21309
21310 static PyObject *_wrap_Effects_Set(PyObject *, PyObject *args, PyObject *kwargs) {
21311 PyObject *resultobj;
21312 wxEffects *arg1 = (wxEffects *) 0 ;
21313 wxColour *arg2 = 0 ;
21314 wxColour *arg3 = 0 ;
21315 wxColour *arg4 = 0 ;
21316 wxColour *arg5 = 0 ;
21317 wxColour *arg6 = 0 ;
21318 wxColour temp2 ;
21319 wxColour temp3 ;
21320 wxColour temp4 ;
21321 wxColour temp5 ;
21322 wxColour temp6 ;
21323 PyObject * obj0 = 0 ;
21324 PyObject * obj1 = 0 ;
21325 PyObject * obj2 = 0 ;
21326 PyObject * obj3 = 0 ;
21327 PyObject * obj4 = 0 ;
21328 PyObject * obj5 = 0 ;
21329 char *kwnames[] = {
21330 (char *) "self",(char *) "highlightColour",(char *) "lightShadow",(char *) "faceColour",(char *) "mediumShadow",(char *) "darkShadow", NULL
21331 };
21332
21333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Effects_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
21334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21335 if (SWIG_arg_fail(1)) SWIG_fail;
21336 {
21337 arg2 = &temp2;
21338 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21339 }
21340 {
21341 arg3 = &temp3;
21342 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
21343 }
21344 {
21345 arg4 = &temp4;
21346 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
21347 }
21348 {
21349 arg5 = &temp5;
21350 if ( ! wxColour_helper(obj4, &arg5)) SWIG_fail;
21351 }
21352 {
21353 arg6 = &temp6;
21354 if ( ! wxColour_helper(obj5, &arg6)) SWIG_fail;
21355 }
21356 {
21357 PyThreadState* __tstate = wxPyBeginAllowThreads();
21358 (arg1)->Set((wxColour const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,(wxColour const &)*arg5,(wxColour const &)*arg6);
21359
21360 wxPyEndAllowThreads(__tstate);
21361 if (PyErr_Occurred()) SWIG_fail;
21362 }
21363 Py_INCREF(Py_None); resultobj = Py_None;
21364 return resultobj;
21365 fail:
21366 return NULL;
21367 }
21368
21369
21370 static PyObject *_wrap_Effects_DrawSunkenEdge(PyObject *, PyObject *args, PyObject *kwargs) {
21371 PyObject *resultobj;
21372 wxEffects *arg1 = (wxEffects *) 0 ;
21373 wxDC *arg2 = 0 ;
21374 wxRect *arg3 = 0 ;
21375 int arg4 = (int) 1 ;
21376 wxRect temp3 ;
21377 PyObject * obj0 = 0 ;
21378 PyObject * obj1 = 0 ;
21379 PyObject * obj2 = 0 ;
21380 PyObject * obj3 = 0 ;
21381 char *kwnames[] = {
21382 (char *) "self",(char *) "dc",(char *) "rect",(char *) "borderSize", NULL
21383 };
21384
21385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Effects_DrawSunkenEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21387 if (SWIG_arg_fail(1)) SWIG_fail;
21388 {
21389 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21390 if (SWIG_arg_fail(2)) SWIG_fail;
21391 if (arg2 == NULL) {
21392 SWIG_null_ref("wxDC");
21393 }
21394 if (SWIG_arg_fail(2)) SWIG_fail;
21395 }
21396 {
21397 arg3 = &temp3;
21398 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
21399 }
21400 if (obj3) {
21401 {
21402 arg4 = (int)(SWIG_As_int(obj3));
21403 if (SWIG_arg_fail(4)) SWIG_fail;
21404 }
21405 }
21406 {
21407 PyThreadState* __tstate = wxPyBeginAllowThreads();
21408 (arg1)->DrawSunkenEdge(*arg2,(wxRect const &)*arg3,arg4);
21409
21410 wxPyEndAllowThreads(__tstate);
21411 if (PyErr_Occurred()) SWIG_fail;
21412 }
21413 Py_INCREF(Py_None); resultobj = Py_None;
21414 return resultobj;
21415 fail:
21416 return NULL;
21417 }
21418
21419
21420 static PyObject *_wrap_Effects_TileBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
21421 PyObject *resultobj;
21422 wxEffects *arg1 = (wxEffects *) 0 ;
21423 wxRect *arg2 = 0 ;
21424 wxDC *arg3 = 0 ;
21425 wxBitmap *arg4 = 0 ;
21426 bool result;
21427 wxRect temp2 ;
21428 PyObject * obj0 = 0 ;
21429 PyObject * obj1 = 0 ;
21430 PyObject * obj2 = 0 ;
21431 PyObject * obj3 = 0 ;
21432 char *kwnames[] = {
21433 (char *) "self",(char *) "rect",(char *) "dc",(char *) "bitmap", NULL
21434 };
21435
21436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Effects_TileBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21438 if (SWIG_arg_fail(1)) SWIG_fail;
21439 {
21440 arg2 = &temp2;
21441 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
21442 }
21443 {
21444 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21445 if (SWIG_arg_fail(3)) SWIG_fail;
21446 if (arg3 == NULL) {
21447 SWIG_null_ref("wxDC");
21448 }
21449 if (SWIG_arg_fail(3)) SWIG_fail;
21450 }
21451 {
21452 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
21453 if (SWIG_arg_fail(4)) SWIG_fail;
21454 if (arg4 == NULL) {
21455 SWIG_null_ref("wxBitmap");
21456 }
21457 if (SWIG_arg_fail(4)) SWIG_fail;
21458 }
21459 {
21460 PyThreadState* __tstate = wxPyBeginAllowThreads();
21461 result = (bool)(arg1)->TileBitmap((wxRect const &)*arg2,*arg3,*arg4);
21462
21463 wxPyEndAllowThreads(__tstate);
21464 if (PyErr_Occurred()) SWIG_fail;
21465 }
21466 {
21467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21468 }
21469 return resultobj;
21470 fail:
21471 return NULL;
21472 }
21473
21474
21475 static PyObject * Effects_swigregister(PyObject *, PyObject *args) {
21476 PyObject *obj;
21477 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21478 SWIG_TypeClientData(SWIGTYPE_p_wxEffects, obj);
21479 Py_INCREF(obj);
21480 return Py_BuildValue((char *)"");
21481 }
21482 static PyObject *_wrap_new_SplitterRenderParams(PyObject *, PyObject *args, PyObject *kwargs) {
21483 PyObject *resultobj;
21484 int arg1 ;
21485 int arg2 ;
21486 bool arg3 ;
21487 wxSplitterRenderParams *result;
21488 PyObject * obj0 = 0 ;
21489 PyObject * obj1 = 0 ;
21490 PyObject * obj2 = 0 ;
21491 char *kwnames[] = {
21492 (char *) "widthSash_",(char *) "border_",(char *) "isSens_", NULL
21493 };
21494
21495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_SplitterRenderParams",kwnames,&obj0,&obj1,&obj2)) goto fail;
21496 {
21497 arg1 = (int)(SWIG_As_int(obj0));
21498 if (SWIG_arg_fail(1)) SWIG_fail;
21499 }
21500 {
21501 arg2 = (int)(SWIG_As_int(obj1));
21502 if (SWIG_arg_fail(2)) SWIG_fail;
21503 }
21504 {
21505 arg3 = (bool)(SWIG_As_bool(obj2));
21506 if (SWIG_arg_fail(3)) SWIG_fail;
21507 }
21508 {
21509 PyThreadState* __tstate = wxPyBeginAllowThreads();
21510 result = (wxSplitterRenderParams *)new wxSplitterRenderParams(arg1,arg2,arg3);
21511
21512 wxPyEndAllowThreads(__tstate);
21513 if (PyErr_Occurred()) SWIG_fail;
21514 }
21515 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSplitterRenderParams, 1);
21516 return resultobj;
21517 fail:
21518 return NULL;
21519 }
21520
21521
21522 static PyObject *_wrap_delete_SplitterRenderParams(PyObject *, PyObject *args, PyObject *kwargs) {
21523 PyObject *resultobj;
21524 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
21525 PyObject * obj0 = 0 ;
21526 char *kwnames[] = {
21527 (char *) "self", NULL
21528 };
21529
21530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SplitterRenderParams",kwnames,&obj0)) goto fail;
21531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_EXCEPTION | 0);
21532 if (SWIG_arg_fail(1)) SWIG_fail;
21533 {
21534 PyThreadState* __tstate = wxPyBeginAllowThreads();
21535 delete arg1;
21536
21537 wxPyEndAllowThreads(__tstate);
21538 if (PyErr_Occurred()) SWIG_fail;
21539 }
21540 Py_INCREF(Py_None); resultobj = Py_None;
21541 return resultobj;
21542 fail:
21543 return NULL;
21544 }
21545
21546
21547 static PyObject *_wrap_SplitterRenderParams_widthSash_get(PyObject *, PyObject *args, PyObject *kwargs) {
21548 PyObject *resultobj;
21549 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
21550 int result;
21551 PyObject * obj0 = 0 ;
21552 char *kwnames[] = {
21553 (char *) "self", NULL
21554 };
21555
21556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterRenderParams_widthSash_get",kwnames,&obj0)) goto fail;
21557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_EXCEPTION | 0);
21558 if (SWIG_arg_fail(1)) SWIG_fail;
21559 result = (int)(int) ((arg1)->widthSash);
21560
21561 {
21562 resultobj = SWIG_From_int((int)(result));
21563 }
21564 return resultobj;
21565 fail:
21566 return NULL;
21567 }
21568
21569
21570 static PyObject *_wrap_SplitterRenderParams_border_get(PyObject *, PyObject *args, PyObject *kwargs) {
21571 PyObject *resultobj;
21572 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
21573 int result;
21574 PyObject * obj0 = 0 ;
21575 char *kwnames[] = {
21576 (char *) "self", NULL
21577 };
21578
21579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterRenderParams_border_get",kwnames,&obj0)) goto fail;
21580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_EXCEPTION | 0);
21581 if (SWIG_arg_fail(1)) SWIG_fail;
21582 result = (int)(int) ((arg1)->border);
21583
21584 {
21585 resultobj = SWIG_From_int((int)(result));
21586 }
21587 return resultobj;
21588 fail:
21589 return NULL;
21590 }
21591
21592
21593 static PyObject *_wrap_SplitterRenderParams_isHotSensitive_get(PyObject *, PyObject *args, PyObject *kwargs) {
21594 PyObject *resultobj;
21595 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
21596 bool result;
21597 PyObject * obj0 = 0 ;
21598 char *kwnames[] = {
21599 (char *) "self", NULL
21600 };
21601
21602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterRenderParams_isHotSensitive_get",kwnames,&obj0)) goto fail;
21603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_EXCEPTION | 0);
21604 if (SWIG_arg_fail(1)) SWIG_fail;
21605 result = (bool)(bool) ((arg1)->isHotSensitive);
21606
21607 {
21608 resultobj = SWIG_From_bool((bool)(result));
21609 }
21610 return resultobj;
21611 fail:
21612 return NULL;
21613 }
21614
21615
21616 static PyObject * SplitterRenderParams_swigregister(PyObject *, PyObject *args) {
21617 PyObject *obj;
21618 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21619 SWIG_TypeClientData(SWIGTYPE_p_wxSplitterRenderParams, obj);
21620 Py_INCREF(obj);
21621 return Py_BuildValue((char *)"");
21622 }
21623 static PyObject *_wrap_new_RendererVersion(PyObject *, PyObject *args, PyObject *kwargs) {
21624 PyObject *resultobj;
21625 int arg1 ;
21626 int arg2 ;
21627 wxRendererVersion *result;
21628 PyObject * obj0 = 0 ;
21629 PyObject * obj1 = 0 ;
21630 char *kwnames[] = {
21631 (char *) "version_",(char *) "age_", NULL
21632 };
21633
21634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RendererVersion",kwnames,&obj0,&obj1)) goto fail;
21635 {
21636 arg1 = (int)(SWIG_As_int(obj0));
21637 if (SWIG_arg_fail(1)) SWIG_fail;
21638 }
21639 {
21640 arg2 = (int)(SWIG_As_int(obj1));
21641 if (SWIG_arg_fail(2)) SWIG_fail;
21642 }
21643 {
21644 PyThreadState* __tstate = wxPyBeginAllowThreads();
21645 result = (wxRendererVersion *)new wxRendererVersion(arg1,arg2);
21646
21647 wxPyEndAllowThreads(__tstate);
21648 if (PyErr_Occurred()) SWIG_fail;
21649 }
21650 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRendererVersion, 1);
21651 return resultobj;
21652 fail:
21653 return NULL;
21654 }
21655
21656
21657 static PyObject *_wrap_delete_RendererVersion(PyObject *, PyObject *args, PyObject *kwargs) {
21658 PyObject *resultobj;
21659 wxRendererVersion *arg1 = (wxRendererVersion *) 0 ;
21660 PyObject * obj0 = 0 ;
21661 char *kwnames[] = {
21662 (char *) "self", NULL
21663 };
21664
21665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RendererVersion",kwnames,&obj0)) goto fail;
21666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_EXCEPTION | 0);
21667 if (SWIG_arg_fail(1)) SWIG_fail;
21668 {
21669 PyThreadState* __tstate = wxPyBeginAllowThreads();
21670 delete arg1;
21671
21672 wxPyEndAllowThreads(__tstate);
21673 if (PyErr_Occurred()) SWIG_fail;
21674 }
21675 Py_INCREF(Py_None); resultobj = Py_None;
21676 return resultobj;
21677 fail:
21678 return NULL;
21679 }
21680
21681
21682 static PyObject *_wrap_RendererVersion_IsCompatible(PyObject *, PyObject *args, PyObject *kwargs) {
21683 PyObject *resultobj;
21684 wxRendererVersion *arg1 = 0 ;
21685 bool result;
21686 PyObject * obj0 = 0 ;
21687 char *kwnames[] = {
21688 (char *) "ver", NULL
21689 };
21690
21691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererVersion_IsCompatible",kwnames,&obj0)) goto fail;
21692 {
21693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_EXCEPTION | 0);
21694 if (SWIG_arg_fail(1)) SWIG_fail;
21695 if (arg1 == NULL) {
21696 SWIG_null_ref("wxRendererVersion");
21697 }
21698 if (SWIG_arg_fail(1)) SWIG_fail;
21699 }
21700 {
21701 PyThreadState* __tstate = wxPyBeginAllowThreads();
21702 result = (bool)wxRendererVersion::IsCompatible((wxRendererVersion const &)*arg1);
21703
21704 wxPyEndAllowThreads(__tstate);
21705 if (PyErr_Occurred()) SWIG_fail;
21706 }
21707 {
21708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21709 }
21710 return resultobj;
21711 fail:
21712 return NULL;
21713 }
21714
21715
21716 static PyObject *_wrap_RendererVersion_version_get(PyObject *, PyObject *args, PyObject *kwargs) {
21717 PyObject *resultobj;
21718 wxRendererVersion *arg1 = (wxRendererVersion *) 0 ;
21719 int result;
21720 PyObject * obj0 = 0 ;
21721 char *kwnames[] = {
21722 (char *) "self", NULL
21723 };
21724
21725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererVersion_version_get",kwnames,&obj0)) goto fail;
21726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_EXCEPTION | 0);
21727 if (SWIG_arg_fail(1)) SWIG_fail;
21728 result = (int)(int) ((arg1)->version);
21729
21730 {
21731 resultobj = SWIG_From_int((int)(result));
21732 }
21733 return resultobj;
21734 fail:
21735 return NULL;
21736 }
21737
21738
21739 static PyObject *_wrap_RendererVersion_age_get(PyObject *, PyObject *args, PyObject *kwargs) {
21740 PyObject *resultobj;
21741 wxRendererVersion *arg1 = (wxRendererVersion *) 0 ;
21742 int result;
21743 PyObject * obj0 = 0 ;
21744 char *kwnames[] = {
21745 (char *) "self", NULL
21746 };
21747
21748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererVersion_age_get",kwnames,&obj0)) goto fail;
21749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_EXCEPTION | 0);
21750 if (SWIG_arg_fail(1)) SWIG_fail;
21751 result = (int)(int) ((arg1)->age);
21752
21753 {
21754 resultobj = SWIG_From_int((int)(result));
21755 }
21756 return resultobj;
21757 fail:
21758 return NULL;
21759 }
21760
21761
21762 static PyObject * RendererVersion_swigregister(PyObject *, PyObject *args) {
21763 PyObject *obj;
21764 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21765 SWIG_TypeClientData(SWIGTYPE_p_wxRendererVersion, obj);
21766 Py_INCREF(obj);
21767 return Py_BuildValue((char *)"");
21768 }
21769 static PyObject *_wrap_RendererNative_DrawHeaderButton(PyObject *, PyObject *args, PyObject *kwargs) {
21770 PyObject *resultobj;
21771 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21772 wxWindow *arg2 = (wxWindow *) 0 ;
21773 wxDC *arg3 = 0 ;
21774 wxRect *arg4 = 0 ;
21775 int arg5 = (int) 0 ;
21776 wxRect temp4 ;
21777 PyObject * obj0 = 0 ;
21778 PyObject * obj1 = 0 ;
21779 PyObject * obj2 = 0 ;
21780 PyObject * obj3 = 0 ;
21781 PyObject * obj4 = 0 ;
21782 char *kwnames[] = {
21783 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
21784 };
21785
21786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawHeaderButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
21787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21788 if (SWIG_arg_fail(1)) SWIG_fail;
21789 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21790 if (SWIG_arg_fail(2)) SWIG_fail;
21791 {
21792 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21793 if (SWIG_arg_fail(3)) SWIG_fail;
21794 if (arg3 == NULL) {
21795 SWIG_null_ref("wxDC");
21796 }
21797 if (SWIG_arg_fail(3)) SWIG_fail;
21798 }
21799 {
21800 arg4 = &temp4;
21801 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
21802 }
21803 if (obj4) {
21804 {
21805 arg5 = (int)(SWIG_As_int(obj4));
21806 if (SWIG_arg_fail(5)) SWIG_fail;
21807 }
21808 }
21809 {
21810 PyThreadState* __tstate = wxPyBeginAllowThreads();
21811 (arg1)->DrawHeaderButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
21812
21813 wxPyEndAllowThreads(__tstate);
21814 if (PyErr_Occurred()) SWIG_fail;
21815 }
21816 Py_INCREF(Py_None); resultobj = Py_None;
21817 return resultobj;
21818 fail:
21819 return NULL;
21820 }
21821
21822
21823 static PyObject *_wrap_RendererNative_DrawTreeItemButton(PyObject *, PyObject *args, PyObject *kwargs) {
21824 PyObject *resultobj;
21825 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21826 wxWindow *arg2 = (wxWindow *) 0 ;
21827 wxDC *arg3 = 0 ;
21828 wxRect *arg4 = 0 ;
21829 int arg5 = (int) 0 ;
21830 wxRect temp4 ;
21831 PyObject * obj0 = 0 ;
21832 PyObject * obj1 = 0 ;
21833 PyObject * obj2 = 0 ;
21834 PyObject * obj3 = 0 ;
21835 PyObject * obj4 = 0 ;
21836 char *kwnames[] = {
21837 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
21838 };
21839
21840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawTreeItemButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
21841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21842 if (SWIG_arg_fail(1)) SWIG_fail;
21843 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21844 if (SWIG_arg_fail(2)) SWIG_fail;
21845 {
21846 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21847 if (SWIG_arg_fail(3)) SWIG_fail;
21848 if (arg3 == NULL) {
21849 SWIG_null_ref("wxDC");
21850 }
21851 if (SWIG_arg_fail(3)) SWIG_fail;
21852 }
21853 {
21854 arg4 = &temp4;
21855 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
21856 }
21857 if (obj4) {
21858 {
21859 arg5 = (int)(SWIG_As_int(obj4));
21860 if (SWIG_arg_fail(5)) SWIG_fail;
21861 }
21862 }
21863 {
21864 PyThreadState* __tstate = wxPyBeginAllowThreads();
21865 (arg1)->DrawTreeItemButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
21866
21867 wxPyEndAllowThreads(__tstate);
21868 if (PyErr_Occurred()) SWIG_fail;
21869 }
21870 Py_INCREF(Py_None); resultobj = Py_None;
21871 return resultobj;
21872 fail:
21873 return NULL;
21874 }
21875
21876
21877 static PyObject *_wrap_RendererNative_DrawSplitterBorder(PyObject *, PyObject *args, PyObject *kwargs) {
21878 PyObject *resultobj;
21879 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21880 wxWindow *arg2 = (wxWindow *) 0 ;
21881 wxDC *arg3 = 0 ;
21882 wxRect *arg4 = 0 ;
21883 int arg5 = (int) 0 ;
21884 wxRect temp4 ;
21885 PyObject * obj0 = 0 ;
21886 PyObject * obj1 = 0 ;
21887 PyObject * obj2 = 0 ;
21888 PyObject * obj3 = 0 ;
21889 PyObject * obj4 = 0 ;
21890 char *kwnames[] = {
21891 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
21892 };
21893
21894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawSplitterBorder",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
21895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21896 if (SWIG_arg_fail(1)) SWIG_fail;
21897 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21898 if (SWIG_arg_fail(2)) SWIG_fail;
21899 {
21900 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21901 if (SWIG_arg_fail(3)) SWIG_fail;
21902 if (arg3 == NULL) {
21903 SWIG_null_ref("wxDC");
21904 }
21905 if (SWIG_arg_fail(3)) SWIG_fail;
21906 }
21907 {
21908 arg4 = &temp4;
21909 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
21910 }
21911 if (obj4) {
21912 {
21913 arg5 = (int)(SWIG_As_int(obj4));
21914 if (SWIG_arg_fail(5)) SWIG_fail;
21915 }
21916 }
21917 {
21918 PyThreadState* __tstate = wxPyBeginAllowThreads();
21919 (arg1)->DrawSplitterBorder(arg2,*arg3,(wxRect const &)*arg4,arg5);
21920
21921 wxPyEndAllowThreads(__tstate);
21922 if (PyErr_Occurred()) SWIG_fail;
21923 }
21924 Py_INCREF(Py_None); resultobj = Py_None;
21925 return resultobj;
21926 fail:
21927 return NULL;
21928 }
21929
21930
21931 static PyObject *_wrap_RendererNative_DrawSplitterSash(PyObject *, PyObject *args, PyObject *kwargs) {
21932 PyObject *resultobj;
21933 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21934 wxWindow *arg2 = (wxWindow *) 0 ;
21935 wxDC *arg3 = 0 ;
21936 wxSize *arg4 = 0 ;
21937 int arg5 ;
21938 wxOrientation arg6 ;
21939 int arg7 = (int) 0 ;
21940 wxSize temp4 ;
21941 PyObject * obj0 = 0 ;
21942 PyObject * obj1 = 0 ;
21943 PyObject * obj2 = 0 ;
21944 PyObject * obj3 = 0 ;
21945 PyObject * obj4 = 0 ;
21946 PyObject * obj5 = 0 ;
21947 PyObject * obj6 = 0 ;
21948 char *kwnames[] = {
21949 (char *) "self",(char *) "win",(char *) "dc",(char *) "size",(char *) "position",(char *) "orient",(char *) "flags", NULL
21950 };
21951
21952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:RendererNative_DrawSplitterSash",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
21953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21954 if (SWIG_arg_fail(1)) SWIG_fail;
21955 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21956 if (SWIG_arg_fail(2)) SWIG_fail;
21957 {
21958 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21959 if (SWIG_arg_fail(3)) SWIG_fail;
21960 if (arg3 == NULL) {
21961 SWIG_null_ref("wxDC");
21962 }
21963 if (SWIG_arg_fail(3)) SWIG_fail;
21964 }
21965 {
21966 arg4 = &temp4;
21967 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
21968 }
21969 {
21970 arg5 = (int)(SWIG_As_int(obj4));
21971 if (SWIG_arg_fail(5)) SWIG_fail;
21972 }
21973 {
21974 arg6 = (wxOrientation)(SWIG_As_int(obj5));
21975 if (SWIG_arg_fail(6)) SWIG_fail;
21976 }
21977 if (obj6) {
21978 {
21979 arg7 = (int)(SWIG_As_int(obj6));
21980 if (SWIG_arg_fail(7)) SWIG_fail;
21981 }
21982 }
21983 {
21984 PyThreadState* __tstate = wxPyBeginAllowThreads();
21985 (arg1)->DrawSplitterSash(arg2,*arg3,(wxSize const &)*arg4,arg5,(wxOrientation )arg6,arg7);
21986
21987 wxPyEndAllowThreads(__tstate);
21988 if (PyErr_Occurred()) SWIG_fail;
21989 }
21990 Py_INCREF(Py_None); resultobj = Py_None;
21991 return resultobj;
21992 fail:
21993 return NULL;
21994 }
21995
21996
21997 static PyObject *_wrap_RendererNative_DrawComboBoxDropButton(PyObject *, PyObject *args, PyObject *kwargs) {
21998 PyObject *resultobj;
21999 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
22000 wxWindow *arg2 = (wxWindow *) 0 ;
22001 wxDC *arg3 = 0 ;
22002 wxRect *arg4 = 0 ;
22003 int arg5 = (int) 0 ;
22004 wxRect temp4 ;
22005 PyObject * obj0 = 0 ;
22006 PyObject * obj1 = 0 ;
22007 PyObject * obj2 = 0 ;
22008 PyObject * obj3 = 0 ;
22009 PyObject * obj4 = 0 ;
22010 char *kwnames[] = {
22011 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
22012 };
22013
22014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawComboBoxDropButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
22015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
22016 if (SWIG_arg_fail(1)) SWIG_fail;
22017 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22018 if (SWIG_arg_fail(2)) SWIG_fail;
22019 {
22020 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
22021 if (SWIG_arg_fail(3)) SWIG_fail;
22022 if (arg3 == NULL) {
22023 SWIG_null_ref("wxDC");
22024 }
22025 if (SWIG_arg_fail(3)) SWIG_fail;
22026 }
22027 {
22028 arg4 = &temp4;
22029 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
22030 }
22031 if (obj4) {
22032 {
22033 arg5 = (int)(SWIG_As_int(obj4));
22034 if (SWIG_arg_fail(5)) SWIG_fail;
22035 }
22036 }
22037 {
22038 PyThreadState* __tstate = wxPyBeginAllowThreads();
22039 (arg1)->DrawComboBoxDropButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
22040
22041 wxPyEndAllowThreads(__tstate);
22042 if (PyErr_Occurred()) SWIG_fail;
22043 }
22044 Py_INCREF(Py_None); resultobj = Py_None;
22045 return resultobj;
22046 fail:
22047 return NULL;
22048 }
22049
22050
22051 static PyObject *_wrap_RendererNative_DrawDropArrow(PyObject *, PyObject *args, PyObject *kwargs) {
22052 PyObject *resultobj;
22053 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
22054 wxWindow *arg2 = (wxWindow *) 0 ;
22055 wxDC *arg3 = 0 ;
22056 wxRect *arg4 = 0 ;
22057 int arg5 = (int) 0 ;
22058 wxRect temp4 ;
22059 PyObject * obj0 = 0 ;
22060 PyObject * obj1 = 0 ;
22061 PyObject * obj2 = 0 ;
22062 PyObject * obj3 = 0 ;
22063 PyObject * obj4 = 0 ;
22064 char *kwnames[] = {
22065 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
22066 };
22067
22068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawDropArrow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
22069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
22070 if (SWIG_arg_fail(1)) SWIG_fail;
22071 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22072 if (SWIG_arg_fail(2)) SWIG_fail;
22073 {
22074 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
22075 if (SWIG_arg_fail(3)) SWIG_fail;
22076 if (arg3 == NULL) {
22077 SWIG_null_ref("wxDC");
22078 }
22079 if (SWIG_arg_fail(3)) SWIG_fail;
22080 }
22081 {
22082 arg4 = &temp4;
22083 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
22084 }
22085 if (obj4) {
22086 {
22087 arg5 = (int)(SWIG_As_int(obj4));
22088 if (SWIG_arg_fail(5)) SWIG_fail;
22089 }
22090 }
22091 {
22092 PyThreadState* __tstate = wxPyBeginAllowThreads();
22093 (arg1)->DrawDropArrow(arg2,*arg3,(wxRect const &)*arg4,arg5);
22094
22095 wxPyEndAllowThreads(__tstate);
22096 if (PyErr_Occurred()) SWIG_fail;
22097 }
22098 Py_INCREF(Py_None); resultobj = Py_None;
22099 return resultobj;
22100 fail:
22101 return NULL;
22102 }
22103
22104
22105 static PyObject *_wrap_RendererNative_GetSplitterParams(PyObject *, PyObject *args, PyObject *kwargs) {
22106 PyObject *resultobj;
22107 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
22108 wxWindow *arg2 = (wxWindow *) 0 ;
22109 SwigValueWrapper<wxSplitterRenderParams > result;
22110 PyObject * obj0 = 0 ;
22111 PyObject * obj1 = 0 ;
22112 char *kwnames[] = {
22113 (char *) "self",(char *) "win", NULL
22114 };
22115
22116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RendererNative_GetSplitterParams",kwnames,&obj0,&obj1)) goto fail;
22117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
22118 if (SWIG_arg_fail(1)) SWIG_fail;
22119 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22120 if (SWIG_arg_fail(2)) SWIG_fail;
22121 {
22122 PyThreadState* __tstate = wxPyBeginAllowThreads();
22123 result = (arg1)->GetSplitterParams((wxWindow const *)arg2);
22124
22125 wxPyEndAllowThreads(__tstate);
22126 if (PyErr_Occurred()) SWIG_fail;
22127 }
22128 {
22129 wxSplitterRenderParams * resultptr;
22130 resultptr = new wxSplitterRenderParams((wxSplitterRenderParams &)(result));
22131 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSplitterRenderParams, 1);
22132 }
22133 return resultobj;
22134 fail:
22135 return NULL;
22136 }
22137
22138
22139 static PyObject *_wrap_RendererNative_Get(PyObject *, PyObject *args, PyObject *kwargs) {
22140 PyObject *resultobj;
22141 wxRendererNative *result;
22142 char *kwnames[] = {
22143 NULL
22144 };
22145
22146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":RendererNative_Get",kwnames)) goto fail;
22147 {
22148 PyThreadState* __tstate = wxPyBeginAllowThreads();
22149 {
22150 wxRendererNative &_result_ref = wxRendererNative::Get();
22151 result = (wxRendererNative *) &_result_ref;
22152 }
22153
22154 wxPyEndAllowThreads(__tstate);
22155 if (PyErr_Occurred()) SWIG_fail;
22156 }
22157 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRendererNative, 0);
22158 return resultobj;
22159 fail:
22160 return NULL;
22161 }
22162
22163
22164 static PyObject *_wrap_RendererNative_GetGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
22165 PyObject *resultobj;
22166 wxRendererNative *result;
22167 char *kwnames[] = {
22168 NULL
22169 };
22170
22171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":RendererNative_GetGeneric",kwnames)) goto fail;
22172 {
22173 PyThreadState* __tstate = wxPyBeginAllowThreads();
22174 {
22175 wxRendererNative &_result_ref = wxRendererNative::GetGeneric();
22176 result = (wxRendererNative *) &_result_ref;
22177 }
22178
22179 wxPyEndAllowThreads(__tstate);
22180 if (PyErr_Occurred()) SWIG_fail;
22181 }
22182 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRendererNative, 0);
22183 return resultobj;
22184 fail:
22185 return NULL;
22186 }
22187
22188
22189 static PyObject *_wrap_RendererNative_GetDefault(PyObject *, PyObject *args, PyObject *kwargs) {
22190 PyObject *resultobj;
22191 wxRendererNative *result;
22192 char *kwnames[] = {
22193 NULL
22194 };
22195
22196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":RendererNative_GetDefault",kwnames)) goto fail;
22197 {
22198 PyThreadState* __tstate = wxPyBeginAllowThreads();
22199 {
22200 wxRendererNative &_result_ref = wxRendererNative::GetDefault();
22201 result = (wxRendererNative *) &_result_ref;
22202 }
22203
22204 wxPyEndAllowThreads(__tstate);
22205 if (PyErr_Occurred()) SWIG_fail;
22206 }
22207 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRendererNative, 0);
22208 return resultobj;
22209 fail:
22210 return NULL;
22211 }
22212
22213
22214 static PyObject *_wrap_RendererNative_Set(PyObject *, PyObject *args, PyObject *kwargs) {
22215 PyObject *resultobj;
22216 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
22217 wxRendererNative *result;
22218 PyObject * obj0 = 0 ;
22219 char *kwnames[] = {
22220 (char *) "renderer", NULL
22221 };
22222
22223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererNative_Set",kwnames,&obj0)) goto fail;
22224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
22225 if (SWIG_arg_fail(1)) SWIG_fail;
22226 {
22227 PyThreadState* __tstate = wxPyBeginAllowThreads();
22228 result = (wxRendererNative *)wxRendererNative::Set(arg1);
22229
22230 wxPyEndAllowThreads(__tstate);
22231 if (PyErr_Occurred()) SWIG_fail;
22232 }
22233 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRendererNative, 0);
22234 return resultobj;
22235 fail:
22236 return NULL;
22237 }
22238
22239
22240 static PyObject *_wrap_RendererNative_GetVersion(PyObject *, PyObject *args, PyObject *kwargs) {
22241 PyObject *resultobj;
22242 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
22243 SwigValueWrapper<wxRendererVersion > result;
22244 PyObject * obj0 = 0 ;
22245 char *kwnames[] = {
22246 (char *) "self", NULL
22247 };
22248
22249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererNative_GetVersion",kwnames,&obj0)) goto fail;
22250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
22251 if (SWIG_arg_fail(1)) SWIG_fail;
22252 {
22253 PyThreadState* __tstate = wxPyBeginAllowThreads();
22254 result = ((wxRendererNative const *)arg1)->GetVersion();
22255
22256 wxPyEndAllowThreads(__tstate);
22257 if (PyErr_Occurred()) SWIG_fail;
22258 }
22259 {
22260 wxRendererVersion * resultptr;
22261 resultptr = new wxRendererVersion((wxRendererVersion &)(result));
22262 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRendererVersion, 1);
22263 }
22264 return resultobj;
22265 fail:
22266 return NULL;
22267 }
22268
22269
22270 static PyObject * RendererNative_swigregister(PyObject *, PyObject *args) {
22271 PyObject *obj;
22272 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22273 SWIG_TypeClientData(SWIGTYPE_p_wxRendererNative, obj);
22274 Py_INCREF(obj);
22275 return Py_BuildValue((char *)"");
22276 }
22277 static PyMethodDef SwigMethods[] = {
22278 { (char *)"new_GDIObject", (PyCFunction) _wrap_new_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
22279 { (char *)"delete_GDIObject", (PyCFunction) _wrap_delete_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
22280 { (char *)"GDIObject_GetVisible", (PyCFunction) _wrap_GDIObject_GetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
22281 { (char *)"GDIObject_SetVisible", (PyCFunction) _wrap_GDIObject_SetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
22282 { (char *)"GDIObject_IsNull", (PyCFunction) _wrap_GDIObject_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
22283 { (char *)"GDIObject_swigregister", GDIObject_swigregister, METH_VARARGS, NULL},
22284 { (char *)"new_Colour", (PyCFunction) _wrap_new_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
22285 { (char *)"new_NamedColour", (PyCFunction) _wrap_new_NamedColour, METH_VARARGS | METH_KEYWORDS, NULL},
22286 { (char *)"new_ColourRGB", (PyCFunction) _wrap_new_ColourRGB, METH_VARARGS | METH_KEYWORDS, NULL},
22287 { (char *)"delete_Colour", (PyCFunction) _wrap_delete_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
22288 { (char *)"Colour_Red", (PyCFunction) _wrap_Colour_Red, METH_VARARGS | METH_KEYWORDS, NULL},
22289 { (char *)"Colour_Green", (PyCFunction) _wrap_Colour_Green, METH_VARARGS | METH_KEYWORDS, NULL},
22290 { (char *)"Colour_Blue", (PyCFunction) _wrap_Colour_Blue, METH_VARARGS | METH_KEYWORDS, NULL},
22291 { (char *)"Colour_Ok", (PyCFunction) _wrap_Colour_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
22292 { (char *)"Colour_Set", (PyCFunction) _wrap_Colour_Set, METH_VARARGS | METH_KEYWORDS, NULL},
22293 { (char *)"Colour_SetRGB", (PyCFunction) _wrap_Colour_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
22294 { (char *)"Colour_SetFromName", (PyCFunction) _wrap_Colour_SetFromName, METH_VARARGS | METH_KEYWORDS, NULL},
22295 { (char *)"Colour_GetPixel", (PyCFunction) _wrap_Colour_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
22296 { (char *)"Colour___eq__", (PyCFunction) _wrap_Colour___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
22297 { (char *)"Colour___ne__", (PyCFunction) _wrap_Colour___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
22298 { (char *)"Colour_Get", (PyCFunction) _wrap_Colour_Get, METH_VARARGS | METH_KEYWORDS, NULL},
22299 { (char *)"Colour_GetRGB", (PyCFunction) _wrap_Colour_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
22300 { (char *)"Colour_swigregister", Colour_swigregister, METH_VARARGS, NULL},
22301 { (char *)"new_Palette", (PyCFunction) _wrap_new_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
22302 { (char *)"delete_Palette", (PyCFunction) _wrap_delete_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
22303 { (char *)"Palette_GetPixel", (PyCFunction) _wrap_Palette_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
22304 { (char *)"Palette_GetRGB", (PyCFunction) _wrap_Palette_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
22305 { (char *)"Palette_GetColoursCount", (PyCFunction) _wrap_Palette_GetColoursCount, METH_VARARGS | METH_KEYWORDS, NULL},
22306 { (char *)"Palette_Ok", (PyCFunction) _wrap_Palette_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
22307 { (char *)"Palette_swigregister", Palette_swigregister, METH_VARARGS, NULL},
22308 { (char *)"new_Pen", (PyCFunction) _wrap_new_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
22309 { (char *)"delete_Pen", (PyCFunction) _wrap_delete_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
22310 { (char *)"Pen_GetCap", (PyCFunction) _wrap_Pen_GetCap, METH_VARARGS | METH_KEYWORDS, NULL},
22311 { (char *)"Pen_GetColour", (PyCFunction) _wrap_Pen_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
22312 { (char *)"Pen_GetJoin", (PyCFunction) _wrap_Pen_GetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
22313 { (char *)"Pen_GetStyle", (PyCFunction) _wrap_Pen_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
22314 { (char *)"Pen_GetWidth", (PyCFunction) _wrap_Pen_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22315 { (char *)"Pen_Ok", (PyCFunction) _wrap_Pen_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
22316 { (char *)"Pen_SetCap", (PyCFunction) _wrap_Pen_SetCap, METH_VARARGS | METH_KEYWORDS, NULL},
22317 { (char *)"Pen_SetColour", (PyCFunction) _wrap_Pen_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
22318 { (char *)"Pen_SetJoin", (PyCFunction) _wrap_Pen_SetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
22319 { (char *)"Pen_SetStyle", (PyCFunction) _wrap_Pen_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
22320 { (char *)"Pen_SetWidth", (PyCFunction) _wrap_Pen_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22321 { (char *)"Pen_SetDashes", (PyCFunction) _wrap_Pen_SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
22322 { (char *)"Pen_GetDashes", (PyCFunction) _wrap_Pen_GetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
22323 { (char *)"Pen__SetDashes", (PyCFunction) _wrap_Pen__SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
22324 { (char *)"Pen_GetDashCount", (PyCFunction) _wrap_Pen_GetDashCount, METH_VARARGS | METH_KEYWORDS, NULL},
22325 { (char *)"Pen_GetStipple", (PyCFunction) _wrap_Pen_GetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
22326 { (char *)"Pen_SetStipple", (PyCFunction) _wrap_Pen_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
22327 { (char *)"Pen___eq__", (PyCFunction) _wrap_Pen___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
22328 { (char *)"Pen___ne__", (PyCFunction) _wrap_Pen___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
22329 { (char *)"Pen_swigregister", Pen_swigregister, METH_VARARGS, NULL},
22330 { (char *)"new_Brush", (PyCFunction) _wrap_new_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
22331 { (char *)"new_BrushFromBitmap", (PyCFunction) _wrap_new_BrushFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22332 { (char *)"delete_Brush", (PyCFunction) _wrap_delete_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
22333 { (char *)"Brush_SetColour", (PyCFunction) _wrap_Brush_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
22334 { (char *)"Brush_SetStyle", (PyCFunction) _wrap_Brush_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
22335 { (char *)"Brush_SetStipple", (PyCFunction) _wrap_Brush_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
22336 { (char *)"Brush_GetColour", (PyCFunction) _wrap_Brush_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
22337 { (char *)"Brush_GetStyle", (PyCFunction) _wrap_Brush_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
22338 { (char *)"Brush_GetStipple", (PyCFunction) _wrap_Brush_GetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
22339 { (char *)"Brush_IsHatch", (PyCFunction) _wrap_Brush_IsHatch, METH_VARARGS | METH_KEYWORDS, NULL},
22340 { (char *)"Brush_Ok", (PyCFunction) _wrap_Brush_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
22341 { (char *)"Brush_swigregister", Brush_swigregister, METH_VARARGS, NULL},
22342 { (char *)"new_Bitmap", (PyCFunction) _wrap_new_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22343 { (char *)"delete_Bitmap", (PyCFunction) _wrap_delete_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22344 { (char *)"new_EmptyBitmap", (PyCFunction) _wrap_new_EmptyBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22345 { (char *)"new_BitmapFromIcon", (PyCFunction) _wrap_new_BitmapFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
22346 { (char *)"new_BitmapFromImage", (PyCFunction) _wrap_new_BitmapFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
22347 { (char *)"new_BitmapFromXPMData", (PyCFunction) _wrap_new_BitmapFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
22348 { (char *)"new_BitmapFromBits", (PyCFunction) _wrap_new_BitmapFromBits, METH_VARARGS | METH_KEYWORDS, NULL},
22349 { (char *)"Bitmap_GetHandle", (PyCFunction) _wrap_Bitmap_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
22350 { (char *)"Bitmap_SetHandle", (PyCFunction) _wrap_Bitmap_SetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
22351 { (char *)"Bitmap_Ok", (PyCFunction) _wrap_Bitmap_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
22352 { (char *)"Bitmap_GetWidth", (PyCFunction) _wrap_Bitmap_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22353 { (char *)"Bitmap_GetHeight", (PyCFunction) _wrap_Bitmap_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
22354 { (char *)"Bitmap_GetDepth", (PyCFunction) _wrap_Bitmap_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
22355 { (char *)"Bitmap_GetSize", (PyCFunction) _wrap_Bitmap_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
22356 { (char *)"Bitmap_ConvertToImage", (PyCFunction) _wrap_Bitmap_ConvertToImage, METH_VARARGS | METH_KEYWORDS, NULL},
22357 { (char *)"Bitmap_GetMask", (PyCFunction) _wrap_Bitmap_GetMask, METH_VARARGS | METH_KEYWORDS, NULL},
22358 { (char *)"Bitmap_SetMask", (PyCFunction) _wrap_Bitmap_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
22359 { (char *)"Bitmap_SetMaskColour", (PyCFunction) _wrap_Bitmap_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
22360 { (char *)"Bitmap_GetSubBitmap", (PyCFunction) _wrap_Bitmap_GetSubBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22361 { (char *)"Bitmap_SaveFile", (PyCFunction) _wrap_Bitmap_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
22362 { (char *)"Bitmap_LoadFile", (PyCFunction) _wrap_Bitmap_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
22363 { (char *)"Bitmap_GetPalette", (PyCFunction) _wrap_Bitmap_GetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
22364 { (char *)"Bitmap_SetPalette", (PyCFunction) _wrap_Bitmap_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
22365 { (char *)"Bitmap_CopyFromIcon", (PyCFunction) _wrap_Bitmap_CopyFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
22366 { (char *)"Bitmap_SetHeight", (PyCFunction) _wrap_Bitmap_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
22367 { (char *)"Bitmap_SetWidth", (PyCFunction) _wrap_Bitmap_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22368 { (char *)"Bitmap_SetDepth", (PyCFunction) _wrap_Bitmap_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
22369 { (char *)"Bitmap_SetSize", (PyCFunction) _wrap_Bitmap_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
22370 { (char *)"Bitmap_CopyFromCursor", (PyCFunction) _wrap_Bitmap_CopyFromCursor, METH_VARARGS | METH_KEYWORDS, NULL},
22371 { (char *)"Bitmap___eq__", (PyCFunction) _wrap_Bitmap___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
22372 { (char *)"Bitmap___ne__", (PyCFunction) _wrap_Bitmap___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
22373 { (char *)"Bitmap_swigregister", Bitmap_swigregister, METH_VARARGS, NULL},
22374 { (char *)"new_Mask", (PyCFunction) _wrap_new_Mask, METH_VARARGS | METH_KEYWORDS, NULL},
22375 { (char *)"Mask_swigregister", Mask_swigregister, METH_VARARGS, NULL},
22376 { (char *)"new_Icon", (PyCFunction) _wrap_new_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
22377 { (char *)"delete_Icon", (PyCFunction) _wrap_delete_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
22378 { (char *)"new_EmptyIcon", (PyCFunction) _wrap_new_EmptyIcon, METH_VARARGS | METH_KEYWORDS, NULL},
22379 { (char *)"new_IconFromLocation", (PyCFunction) _wrap_new_IconFromLocation, METH_VARARGS | METH_KEYWORDS, NULL},
22380 { (char *)"new_IconFromBitmap", (PyCFunction) _wrap_new_IconFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22381 { (char *)"new_IconFromXPMData", (PyCFunction) _wrap_new_IconFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
22382 { (char *)"Icon_LoadFile", (PyCFunction) _wrap_Icon_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
22383 { (char *)"Icon_GetHandle", (PyCFunction) _wrap_Icon_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
22384 { (char *)"Icon_SetHandle", (PyCFunction) _wrap_Icon_SetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
22385 { (char *)"Icon_Ok", (PyCFunction) _wrap_Icon_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
22386 { (char *)"Icon_GetWidth", (PyCFunction) _wrap_Icon_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22387 { (char *)"Icon_GetHeight", (PyCFunction) _wrap_Icon_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
22388 { (char *)"Icon_GetDepth", (PyCFunction) _wrap_Icon_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
22389 { (char *)"Icon_SetWidth", (PyCFunction) _wrap_Icon_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22390 { (char *)"Icon_SetHeight", (PyCFunction) _wrap_Icon_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
22391 { (char *)"Icon_SetDepth", (PyCFunction) _wrap_Icon_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
22392 { (char *)"Icon_SetSize", (PyCFunction) _wrap_Icon_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
22393 { (char *)"Icon_CopyFromBitmap", (PyCFunction) _wrap_Icon_CopyFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22394 { (char *)"Icon_swigregister", Icon_swigregister, METH_VARARGS, NULL},
22395 { (char *)"new_IconLocation", (PyCFunction) _wrap_new_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
22396 { (char *)"delete_IconLocation", (PyCFunction) _wrap_delete_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
22397 { (char *)"IconLocation_IsOk", (PyCFunction) _wrap_IconLocation_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
22398 { (char *)"IconLocation_SetFileName", (PyCFunction) _wrap_IconLocation_SetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
22399 { (char *)"IconLocation_GetFileName", (PyCFunction) _wrap_IconLocation_GetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
22400 { (char *)"IconLocation_SetIndex", (PyCFunction) _wrap_IconLocation_SetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
22401 { (char *)"IconLocation_GetIndex", (PyCFunction) _wrap_IconLocation_GetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
22402 { (char *)"IconLocation_swigregister", IconLocation_swigregister, METH_VARARGS, NULL},
22403 { (char *)"new_IconBundle", (PyCFunction) _wrap_new_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
22404 { (char *)"new_IconBundleFromFile", (PyCFunction) _wrap_new_IconBundleFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
22405 { (char *)"new_IconBundleFromIcon", (PyCFunction) _wrap_new_IconBundleFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
22406 { (char *)"delete_IconBundle", (PyCFunction) _wrap_delete_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
22407 { (char *)"IconBundle_AddIcon", (PyCFunction) _wrap_IconBundle_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
22408 { (char *)"IconBundle_AddIconFromFile", (PyCFunction) _wrap_IconBundle_AddIconFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
22409 { (char *)"IconBundle_GetIcon", (PyCFunction) _wrap_IconBundle_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
22410 { (char *)"IconBundle_swigregister", IconBundle_swigregister, METH_VARARGS, NULL},
22411 { (char *)"new_Cursor", (PyCFunction) _wrap_new_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
22412 { (char *)"delete_Cursor", (PyCFunction) _wrap_delete_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
22413 { (char *)"new_StockCursor", (PyCFunction) _wrap_new_StockCursor, METH_VARARGS | METH_KEYWORDS, NULL},
22414 { (char *)"new_CursorFromImage", (PyCFunction) _wrap_new_CursorFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
22415 { (char *)"Cursor_GetHandle", (PyCFunction) _wrap_Cursor_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
22416 { (char *)"Cursor_SetHandle", (PyCFunction) _wrap_Cursor_SetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
22417 { (char *)"Cursor_Ok", (PyCFunction) _wrap_Cursor_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
22418 { (char *)"Cursor_GetWidth", (PyCFunction) _wrap_Cursor_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22419 { (char *)"Cursor_GetHeight", (PyCFunction) _wrap_Cursor_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
22420 { (char *)"Cursor_GetDepth", (PyCFunction) _wrap_Cursor_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
22421 { (char *)"Cursor_SetWidth", (PyCFunction) _wrap_Cursor_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22422 { (char *)"Cursor_SetHeight", (PyCFunction) _wrap_Cursor_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
22423 { (char *)"Cursor_SetDepth", (PyCFunction) _wrap_Cursor_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
22424 { (char *)"Cursor_SetSize", (PyCFunction) _wrap_Cursor_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
22425 { (char *)"Cursor_swigregister", Cursor_swigregister, METH_VARARGS, NULL},
22426 { (char *)"new_Region", (PyCFunction) _wrap_new_Region, METH_VARARGS | METH_KEYWORDS, NULL},
22427 { (char *)"new_RegionFromBitmap", (PyCFunction) _wrap_new_RegionFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22428 { (char *)"new_RegionFromBitmapColour", (PyCFunction) _wrap_new_RegionFromBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
22429 { (char *)"new_RegionFromPoints", (PyCFunction) _wrap_new_RegionFromPoints, METH_VARARGS | METH_KEYWORDS, NULL},
22430 { (char *)"delete_Region", (PyCFunction) _wrap_delete_Region, METH_VARARGS | METH_KEYWORDS, NULL},
22431 { (char *)"Region_Clear", (PyCFunction) _wrap_Region_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
22432 { (char *)"Region_Offset", (PyCFunction) _wrap_Region_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
22433 { (char *)"Region_Contains", (PyCFunction) _wrap_Region_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
22434 { (char *)"Region_ContainsPoint", (PyCFunction) _wrap_Region_ContainsPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22435 { (char *)"Region_ContainsRect", (PyCFunction) _wrap_Region_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
22436 { (char *)"Region_ContainsRectDim", (PyCFunction) _wrap_Region_ContainsRectDim, METH_VARARGS | METH_KEYWORDS, NULL},
22437 { (char *)"Region_GetBox", (PyCFunction) _wrap_Region_GetBox, METH_VARARGS | METH_KEYWORDS, NULL},
22438 { (char *)"Region_Intersect", (PyCFunction) _wrap_Region_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
22439 { (char *)"Region_IntersectRect", (PyCFunction) _wrap_Region_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
22440 { (char *)"Region_IntersectRegion", (PyCFunction) _wrap_Region_IntersectRegion, METH_VARARGS | METH_KEYWORDS, NULL},
22441 { (char *)"Region_IsEmpty", (PyCFunction) _wrap_Region_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
22442 { (char *)"Region_Union", (PyCFunction) _wrap_Region_Union, METH_VARARGS | METH_KEYWORDS, NULL},
22443 { (char *)"Region_UnionRect", (PyCFunction) _wrap_Region_UnionRect, METH_VARARGS | METH_KEYWORDS, NULL},
22444 { (char *)"Region_UnionRegion", (PyCFunction) _wrap_Region_UnionRegion, METH_VARARGS | METH_KEYWORDS, NULL},
22445 { (char *)"Region_Subtract", (PyCFunction) _wrap_Region_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
22446 { (char *)"Region_SubtractRect", (PyCFunction) _wrap_Region_SubtractRect, METH_VARARGS | METH_KEYWORDS, NULL},
22447 { (char *)"Region_SubtractRegion", (PyCFunction) _wrap_Region_SubtractRegion, METH_VARARGS | METH_KEYWORDS, NULL},
22448 { (char *)"Region_Xor", (PyCFunction) _wrap_Region_Xor, METH_VARARGS | METH_KEYWORDS, NULL},
22449 { (char *)"Region_XorRect", (PyCFunction) _wrap_Region_XorRect, METH_VARARGS | METH_KEYWORDS, NULL},
22450 { (char *)"Region_XorRegion", (PyCFunction) _wrap_Region_XorRegion, METH_VARARGS | METH_KEYWORDS, NULL},
22451 { (char *)"Region_ConvertToBitmap", (PyCFunction) _wrap_Region_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22452 { (char *)"Region_UnionBitmap", (PyCFunction) _wrap_Region_UnionBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22453 { (char *)"Region_UnionBitmapColour", (PyCFunction) _wrap_Region_UnionBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
22454 { (char *)"Region_swigregister", Region_swigregister, METH_VARARGS, NULL},
22455 { (char *)"new_RegionIterator", (PyCFunction) _wrap_new_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
22456 { (char *)"delete_RegionIterator", (PyCFunction) _wrap_delete_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
22457 { (char *)"RegionIterator_GetX", (PyCFunction) _wrap_RegionIterator_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
22458 { (char *)"RegionIterator_GetY", (PyCFunction) _wrap_RegionIterator_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
22459 { (char *)"RegionIterator_GetW", (PyCFunction) _wrap_RegionIterator_GetW, METH_VARARGS | METH_KEYWORDS, NULL},
22460 { (char *)"RegionIterator_GetWidth", (PyCFunction) _wrap_RegionIterator_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22461 { (char *)"RegionIterator_GetH", (PyCFunction) _wrap_RegionIterator_GetH, METH_VARARGS | METH_KEYWORDS, NULL},
22462 { (char *)"RegionIterator_GetHeight", (PyCFunction) _wrap_RegionIterator_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
22463 { (char *)"RegionIterator_GetRect", (PyCFunction) _wrap_RegionIterator_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
22464 { (char *)"RegionIterator_HaveRects", (PyCFunction) _wrap_RegionIterator_HaveRects, METH_VARARGS | METH_KEYWORDS, NULL},
22465 { (char *)"RegionIterator_Reset", (PyCFunction) _wrap_RegionIterator_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
22466 { (char *)"RegionIterator_Next", (PyCFunction) _wrap_RegionIterator_Next, METH_VARARGS | METH_KEYWORDS, NULL},
22467 { (char *)"RegionIterator___nonzero__", (PyCFunction) _wrap_RegionIterator___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
22468 { (char *)"RegionIterator_swigregister", RegionIterator_swigregister, METH_VARARGS, NULL},
22469 { (char *)"new_NativeFontInfo", (PyCFunction) _wrap_new_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
22470 { (char *)"delete_NativeFontInfo", (PyCFunction) _wrap_delete_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
22471 { (char *)"NativeFontInfo_Init", (PyCFunction) _wrap_NativeFontInfo_Init, METH_VARARGS | METH_KEYWORDS, NULL},
22472 { (char *)"NativeFontInfo_InitFromFont", (PyCFunction) _wrap_NativeFontInfo_InitFromFont, METH_VARARGS | METH_KEYWORDS, NULL},
22473 { (char *)"NativeFontInfo_GetPointSize", (PyCFunction) _wrap_NativeFontInfo_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
22474 { (char *)"NativeFontInfo_GetPixelSize", (PyCFunction) _wrap_NativeFontInfo_GetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
22475 { (char *)"NativeFontInfo_GetStyle", (PyCFunction) _wrap_NativeFontInfo_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
22476 { (char *)"NativeFontInfo_GetWeight", (PyCFunction) _wrap_NativeFontInfo_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
22477 { (char *)"NativeFontInfo_GetUnderlined", (PyCFunction) _wrap_NativeFontInfo_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
22478 { (char *)"NativeFontInfo_GetFaceName", (PyCFunction) _wrap_NativeFontInfo_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
22479 { (char *)"NativeFontInfo_GetFamily", (PyCFunction) _wrap_NativeFontInfo_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
22480 { (char *)"NativeFontInfo_GetEncoding", (PyCFunction) _wrap_NativeFontInfo_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
22481 { (char *)"NativeFontInfo_SetPointSize", (PyCFunction) _wrap_NativeFontInfo_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
22482 { (char *)"NativeFontInfo_SetPixelSize", (PyCFunction) _wrap_NativeFontInfo_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
22483 { (char *)"NativeFontInfo_SetStyle", (PyCFunction) _wrap_NativeFontInfo_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
22484 { (char *)"NativeFontInfo_SetWeight", (PyCFunction) _wrap_NativeFontInfo_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
22485 { (char *)"NativeFontInfo_SetUnderlined", (PyCFunction) _wrap_NativeFontInfo_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
22486 { (char *)"NativeFontInfo_SetFaceName", (PyCFunction) _wrap_NativeFontInfo_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
22487 { (char *)"NativeFontInfo_SetFamily", (PyCFunction) _wrap_NativeFontInfo_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
22488 { (char *)"NativeFontInfo_SetEncoding", (PyCFunction) _wrap_NativeFontInfo_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
22489 { (char *)"NativeFontInfo_FromString", (PyCFunction) _wrap_NativeFontInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
22490 { (char *)"NativeFontInfo_ToString", (PyCFunction) _wrap_NativeFontInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
22491 { (char *)"NativeFontInfo___str__", (PyCFunction) _wrap_NativeFontInfo___str__, METH_VARARGS | METH_KEYWORDS, NULL},
22492 { (char *)"NativeFontInfo_FromUserString", (PyCFunction) _wrap_NativeFontInfo_FromUserString, METH_VARARGS | METH_KEYWORDS, NULL},
22493 { (char *)"NativeFontInfo_ToUserString", (PyCFunction) _wrap_NativeFontInfo_ToUserString, METH_VARARGS | METH_KEYWORDS, NULL},
22494 { (char *)"NativeFontInfo_swigregister", NativeFontInfo_swigregister, METH_VARARGS, NULL},
22495 { (char *)"NativeEncodingInfo_facename_set", (PyCFunction) _wrap_NativeEncodingInfo_facename_set, METH_VARARGS | METH_KEYWORDS, NULL},
22496 { (char *)"NativeEncodingInfo_facename_get", (PyCFunction) _wrap_NativeEncodingInfo_facename_get, METH_VARARGS | METH_KEYWORDS, NULL},
22497 { (char *)"NativeEncodingInfo_encoding_set", (PyCFunction) _wrap_NativeEncodingInfo_encoding_set, METH_VARARGS | METH_KEYWORDS, NULL},
22498 { (char *)"NativeEncodingInfo_encoding_get", (PyCFunction) _wrap_NativeEncodingInfo_encoding_get, METH_VARARGS | METH_KEYWORDS, NULL},
22499 { (char *)"new_NativeEncodingInfo", (PyCFunction) _wrap_new_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
22500 { (char *)"delete_NativeEncodingInfo", (PyCFunction) _wrap_delete_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
22501 { (char *)"NativeEncodingInfo_FromString", (PyCFunction) _wrap_NativeEncodingInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
22502 { (char *)"NativeEncodingInfo_ToString", (PyCFunction) _wrap_NativeEncodingInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
22503 { (char *)"NativeEncodingInfo_swigregister", NativeEncodingInfo_swigregister, METH_VARARGS, NULL},
22504 { (char *)"GetNativeFontEncoding", (PyCFunction) _wrap_GetNativeFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
22505 { (char *)"TestFontEncoding", (PyCFunction) _wrap_TestFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
22506 { (char *)"new_FontMapper", (PyCFunction) _wrap_new_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
22507 { (char *)"delete_FontMapper", (PyCFunction) _wrap_delete_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
22508 { (char *)"FontMapper_Get", (PyCFunction) _wrap_FontMapper_Get, METH_VARARGS | METH_KEYWORDS, NULL},
22509 { (char *)"FontMapper_Set", (PyCFunction) _wrap_FontMapper_Set, METH_VARARGS | METH_KEYWORDS, NULL},
22510 { (char *)"FontMapper_CharsetToEncoding", (PyCFunction) _wrap_FontMapper_CharsetToEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
22511 { (char *)"FontMapper_GetSupportedEncodingsCount", (PyCFunction) _wrap_FontMapper_GetSupportedEncodingsCount, METH_VARARGS | METH_KEYWORDS, NULL},
22512 { (char *)"FontMapper_GetEncoding", (PyCFunction) _wrap_FontMapper_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
22513 { (char *)"FontMapper_GetEncodingName", (PyCFunction) _wrap_FontMapper_GetEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
22514 { (char *)"FontMapper_GetEncodingDescription", (PyCFunction) _wrap_FontMapper_GetEncodingDescription, METH_VARARGS | METH_KEYWORDS, NULL},
22515 { (char *)"FontMapper_GetEncodingFromName", (PyCFunction) _wrap_FontMapper_GetEncodingFromName, METH_VARARGS | METH_KEYWORDS, NULL},
22516 { (char *)"FontMapper_SetConfig", (PyCFunction) _wrap_FontMapper_SetConfig, METH_VARARGS | METH_KEYWORDS, NULL},
22517 { (char *)"FontMapper_SetConfigPath", (PyCFunction) _wrap_FontMapper_SetConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
22518 { (char *)"FontMapper_GetDefaultConfigPath", (PyCFunction) _wrap_FontMapper_GetDefaultConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
22519 { (char *)"FontMapper_GetAltForEncoding", (PyCFunction) _wrap_FontMapper_GetAltForEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
22520 { (char *)"FontMapper_IsEncodingAvailable", (PyCFunction) _wrap_FontMapper_IsEncodingAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
22521 { (char *)"FontMapper_SetDialogParent", (PyCFunction) _wrap_FontMapper_SetDialogParent, METH_VARARGS | METH_KEYWORDS, NULL},
22522 { (char *)"FontMapper_SetDialogTitle", (PyCFunction) _wrap_FontMapper_SetDialogTitle, METH_VARARGS | METH_KEYWORDS, NULL},
22523 { (char *)"FontMapper_swigregister", FontMapper_swigregister, METH_VARARGS, NULL},
22524 { (char *)"new_Font", (PyCFunction) _wrap_new_Font, METH_VARARGS | METH_KEYWORDS, NULL},
22525 { (char *)"delete_Font", (PyCFunction) _wrap_delete_Font, METH_VARARGS | METH_KEYWORDS, NULL},
22526 { (char *)"new_FontFromNativeInfo", (PyCFunction) _wrap_new_FontFromNativeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
22527 { (char *)"new_FontFromNativeInfoString", (PyCFunction) _wrap_new_FontFromNativeInfoString, METH_VARARGS | METH_KEYWORDS, NULL},
22528 { (char *)"new_FFont", (PyCFunction) _wrap_new_FFont, METH_VARARGS | METH_KEYWORDS, NULL},
22529 { (char *)"new_FontFromPixelSize", (PyCFunction) _wrap_new_FontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
22530 { (char *)"new_FFontFromPixelSize", (PyCFunction) _wrap_new_FFontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
22531 { (char *)"Font_Ok", (PyCFunction) _wrap_Font_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
22532 { (char *)"Font___eq__", (PyCFunction) _wrap_Font___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
22533 { (char *)"Font___ne__", (PyCFunction) _wrap_Font___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
22534 { (char *)"Font_GetPointSize", (PyCFunction) _wrap_Font_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
22535 { (char *)"Font_GetPixelSize", (PyCFunction) _wrap_Font_GetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
22536 { (char *)"Font_IsUsingSizeInPixels", (PyCFunction) _wrap_Font_IsUsingSizeInPixels, METH_VARARGS | METH_KEYWORDS, NULL},
22537 { (char *)"Font_GetFamily", (PyCFunction) _wrap_Font_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
22538 { (char *)"Font_GetStyle", (PyCFunction) _wrap_Font_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
22539 { (char *)"Font_GetWeight", (PyCFunction) _wrap_Font_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
22540 { (char *)"Font_GetUnderlined", (PyCFunction) _wrap_Font_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
22541 { (char *)"Font_GetFaceName", (PyCFunction) _wrap_Font_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
22542 { (char *)"Font_GetEncoding", (PyCFunction) _wrap_Font_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
22543 { (char *)"Font_GetNativeFontInfo", (PyCFunction) _wrap_Font_GetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
22544 { (char *)"Font_IsFixedWidth", (PyCFunction) _wrap_Font_IsFixedWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22545 { (char *)"Font_GetNativeFontInfoDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoDesc, METH_VARARGS | METH_KEYWORDS, NULL},
22546 { (char *)"Font_GetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
22547 { (char *)"Font_SetPointSize", (PyCFunction) _wrap_Font_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
22548 { (char *)"Font_SetPixelSize", (PyCFunction) _wrap_Font_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
22549 { (char *)"Font_SetFamily", (PyCFunction) _wrap_Font_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
22550 { (char *)"Font_SetStyle", (PyCFunction) _wrap_Font_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
22551 { (char *)"Font_SetWeight", (PyCFunction) _wrap_Font_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
22552 { (char *)"Font_SetFaceName", (PyCFunction) _wrap_Font_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
22553 { (char *)"Font_SetUnderlined", (PyCFunction) _wrap_Font_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
22554 { (char *)"Font_SetEncoding", (PyCFunction) _wrap_Font_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
22555 { (char *)"Font_SetNativeFontInfo", (PyCFunction) _wrap_Font_SetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
22556 { (char *)"Font_SetNativeFontInfoFromString", (PyCFunction) _wrap_Font_SetNativeFontInfoFromString, METH_VARARGS | METH_KEYWORDS, NULL},
22557 { (char *)"Font_SetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_SetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
22558 { (char *)"Font_GetFamilyString", (PyCFunction) _wrap_Font_GetFamilyString, METH_VARARGS | METH_KEYWORDS, NULL},
22559 { (char *)"Font_GetStyleString", (PyCFunction) _wrap_Font_GetStyleString, METH_VARARGS | METH_KEYWORDS, NULL},
22560 { (char *)"Font_GetWeightString", (PyCFunction) _wrap_Font_GetWeightString, METH_VARARGS | METH_KEYWORDS, NULL},
22561 { (char *)"Font_SetNoAntiAliasing", (PyCFunction) _wrap_Font_SetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
22562 { (char *)"Font_GetNoAntiAliasing", (PyCFunction) _wrap_Font_GetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
22563 { (char *)"Font_GetDefaultEncoding", (PyCFunction) _wrap_Font_GetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
22564 { (char *)"Font_SetDefaultEncoding", (PyCFunction) _wrap_Font_SetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
22565 { (char *)"Font_swigregister", Font_swigregister, METH_VARARGS, NULL},
22566 { (char *)"new_FontEnumerator", (PyCFunction) _wrap_new_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
22567 { (char *)"delete_FontEnumerator", (PyCFunction) _wrap_delete_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
22568 { (char *)"FontEnumerator__setCallbackInfo", (PyCFunction) _wrap_FontEnumerator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
22569 { (char *)"FontEnumerator_EnumerateFacenames", (PyCFunction) _wrap_FontEnumerator_EnumerateFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
22570 { (char *)"FontEnumerator_EnumerateEncodings", (PyCFunction) _wrap_FontEnumerator_EnumerateEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
22571 { (char *)"FontEnumerator_GetEncodings", (PyCFunction) _wrap_FontEnumerator_GetEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
22572 { (char *)"FontEnumerator_GetFacenames", (PyCFunction) _wrap_FontEnumerator_GetFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
22573 { (char *)"FontEnumerator_swigregister", FontEnumerator_swigregister, METH_VARARGS, NULL},
22574 { (char *)"LanguageInfo_Language_set", (PyCFunction) _wrap_LanguageInfo_Language_set, METH_VARARGS | METH_KEYWORDS, NULL},
22575 { (char *)"LanguageInfo_Language_get", (PyCFunction) _wrap_LanguageInfo_Language_get, METH_VARARGS | METH_KEYWORDS, NULL},
22576 { (char *)"LanguageInfo_CanonicalName_set", (PyCFunction) _wrap_LanguageInfo_CanonicalName_set, METH_VARARGS | METH_KEYWORDS, NULL},
22577 { (char *)"LanguageInfo_CanonicalName_get", (PyCFunction) _wrap_LanguageInfo_CanonicalName_get, METH_VARARGS | METH_KEYWORDS, NULL},
22578 { (char *)"LanguageInfo_Description_set", (PyCFunction) _wrap_LanguageInfo_Description_set, METH_VARARGS | METH_KEYWORDS, NULL},
22579 { (char *)"LanguageInfo_Description_get", (PyCFunction) _wrap_LanguageInfo_Description_get, METH_VARARGS | METH_KEYWORDS, NULL},
22580 { (char *)"LanguageInfo_swigregister", LanguageInfo_swigregister, METH_VARARGS, NULL},
22581 { (char *)"new_Locale", (PyCFunction) _wrap_new_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
22582 { (char *)"delete_Locale", (PyCFunction) _wrap_delete_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
22583 { (char *)"Locale_Init1", (PyCFunction) _wrap_Locale_Init1, METH_VARARGS | METH_KEYWORDS, NULL},
22584 { (char *)"Locale_Init2", (PyCFunction) _wrap_Locale_Init2, METH_VARARGS | METH_KEYWORDS, NULL},
22585 { (char *)"Locale_GetSystemLanguage", (PyCFunction) _wrap_Locale_GetSystemLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
22586 { (char *)"Locale_GetSystemEncoding", (PyCFunction) _wrap_Locale_GetSystemEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
22587 { (char *)"Locale_GetSystemEncodingName", (PyCFunction) _wrap_Locale_GetSystemEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
22588 { (char *)"Locale_IsOk", (PyCFunction) _wrap_Locale_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
22589 { (char *)"Locale_GetLocale", (PyCFunction) _wrap_Locale_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
22590 { (char *)"Locale_GetLanguage", (PyCFunction) _wrap_Locale_GetLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
22591 { (char *)"Locale_GetSysName", (PyCFunction) _wrap_Locale_GetSysName, METH_VARARGS | METH_KEYWORDS, NULL},
22592 { (char *)"Locale_GetCanonicalName", (PyCFunction) _wrap_Locale_GetCanonicalName, METH_VARARGS | METH_KEYWORDS, NULL},
22593 { (char *)"Locale_AddCatalogLookupPathPrefix", (PyCFunction) _wrap_Locale_AddCatalogLookupPathPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
22594 { (char *)"Locale_AddCatalog", (PyCFunction) _wrap_Locale_AddCatalog, METH_VARARGS | METH_KEYWORDS, NULL},
22595 { (char *)"Locale_IsLoaded", (PyCFunction) _wrap_Locale_IsLoaded, METH_VARARGS | METH_KEYWORDS, NULL},
22596 { (char *)"Locale_GetLanguageInfo", (PyCFunction) _wrap_Locale_GetLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
22597 { (char *)"Locale_GetLanguageName", (PyCFunction) _wrap_Locale_GetLanguageName, METH_VARARGS | METH_KEYWORDS, NULL},
22598 { (char *)"Locale_FindLanguageInfo", (PyCFunction) _wrap_Locale_FindLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
22599 { (char *)"Locale_AddLanguage", (PyCFunction) _wrap_Locale_AddLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
22600 { (char *)"Locale_GetString", (PyCFunction) _wrap_Locale_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
22601 { (char *)"Locale_GetName", (PyCFunction) _wrap_Locale_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
22602 { (char *)"Locale_swigregister", Locale_swigregister, METH_VARARGS, NULL},
22603 { (char *)"GetLocale", (PyCFunction) _wrap_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
22604 { (char *)"GetTranslation", _wrap_GetTranslation, METH_VARARGS, NULL},
22605 { (char *)"new_EncodingConverter", (PyCFunction) _wrap_new_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
22606 { (char *)"delete_EncodingConverter", (PyCFunction) _wrap_delete_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
22607 { (char *)"EncodingConverter_Init", (PyCFunction) _wrap_EncodingConverter_Init, METH_VARARGS | METH_KEYWORDS, NULL},
22608 { (char *)"EncodingConverter_Convert", (PyCFunction) _wrap_EncodingConverter_Convert, METH_VARARGS | METH_KEYWORDS, NULL},
22609 { (char *)"EncodingConverter_GetPlatformEquivalents", (PyCFunction) _wrap_EncodingConverter_GetPlatformEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
22610 { (char *)"EncodingConverter_GetAllEquivalents", (PyCFunction) _wrap_EncodingConverter_GetAllEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
22611 { (char *)"EncodingConverter_CanConvert", (PyCFunction) _wrap_EncodingConverter_CanConvert, METH_VARARGS | METH_KEYWORDS, NULL},
22612 { (char *)"EncodingConverter_swigregister", EncodingConverter_swigregister, METH_VARARGS, NULL},
22613 { (char *)"delete_DC", (PyCFunction) _wrap_delete_DC, METH_VARARGS | METH_KEYWORDS, NULL},
22614 { (char *)"DC_BeginDrawing", (PyCFunction) _wrap_DC_BeginDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
22615 { (char *)"DC_EndDrawing", (PyCFunction) _wrap_DC_EndDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
22616 { (char *)"DC_FloodFill", (PyCFunction) _wrap_DC_FloodFill, METH_VARARGS | METH_KEYWORDS, NULL},
22617 { (char *)"DC_FloodFillPoint", (PyCFunction) _wrap_DC_FloodFillPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22618 { (char *)"DC_GetPixel", (PyCFunction) _wrap_DC_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
22619 { (char *)"DC_GetPixelPoint", (PyCFunction) _wrap_DC_GetPixelPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22620 { (char *)"DC_DrawLine", (PyCFunction) _wrap_DC_DrawLine, METH_VARARGS | METH_KEYWORDS, NULL},
22621 { (char *)"DC_DrawLinePoint", (PyCFunction) _wrap_DC_DrawLinePoint, METH_VARARGS | METH_KEYWORDS, NULL},
22622 { (char *)"DC_CrossHair", (PyCFunction) _wrap_DC_CrossHair, METH_VARARGS | METH_KEYWORDS, NULL},
22623 { (char *)"DC_CrossHairPoint", (PyCFunction) _wrap_DC_CrossHairPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22624 { (char *)"DC_DrawArc", (PyCFunction) _wrap_DC_DrawArc, METH_VARARGS | METH_KEYWORDS, NULL},
22625 { (char *)"DC_DrawArcPoint", (PyCFunction) _wrap_DC_DrawArcPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22626 { (char *)"DC_DrawCheckMark", (PyCFunction) _wrap_DC_DrawCheckMark, METH_VARARGS | METH_KEYWORDS, NULL},
22627 { (char *)"DC_DrawCheckMarkRect", (PyCFunction) _wrap_DC_DrawCheckMarkRect, METH_VARARGS | METH_KEYWORDS, NULL},
22628 { (char *)"DC_DrawEllipticArc", (PyCFunction) _wrap_DC_DrawEllipticArc, METH_VARARGS | METH_KEYWORDS, NULL},
22629 { (char *)"DC_DrawEllipticArcPointSize", (PyCFunction) _wrap_DC_DrawEllipticArcPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
22630 { (char *)"DC_DrawPoint", (PyCFunction) _wrap_DC_DrawPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22631 { (char *)"DC_DrawPointPoint", (PyCFunction) _wrap_DC_DrawPointPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22632 { (char *)"DC_DrawRectangle", (PyCFunction) _wrap_DC_DrawRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
22633 { (char *)"DC_DrawRectangleRect", (PyCFunction) _wrap_DC_DrawRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
22634 { (char *)"DC_DrawRectanglePointSize", (PyCFunction) _wrap_DC_DrawRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
22635 { (char *)"DC_DrawRoundedRectangle", (PyCFunction) _wrap_DC_DrawRoundedRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
22636 { (char *)"DC_DrawRoundedRectangleRect", (PyCFunction) _wrap_DC_DrawRoundedRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
22637 { (char *)"DC_DrawRoundedRectanglePointSize", (PyCFunction) _wrap_DC_DrawRoundedRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
22638 { (char *)"DC_DrawCircle", (PyCFunction) _wrap_DC_DrawCircle, METH_VARARGS | METH_KEYWORDS, NULL},
22639 { (char *)"DC_DrawCirclePoint", (PyCFunction) _wrap_DC_DrawCirclePoint, METH_VARARGS | METH_KEYWORDS, NULL},
22640 { (char *)"DC_DrawEllipse", (PyCFunction) _wrap_DC_DrawEllipse, METH_VARARGS | METH_KEYWORDS, NULL},
22641 { (char *)"DC_DrawEllipseRect", (PyCFunction) _wrap_DC_DrawEllipseRect, METH_VARARGS | METH_KEYWORDS, NULL},
22642 { (char *)"DC_DrawEllipsePointSize", (PyCFunction) _wrap_DC_DrawEllipsePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
22643 { (char *)"DC_DrawIcon", (PyCFunction) _wrap_DC_DrawIcon, METH_VARARGS | METH_KEYWORDS, NULL},
22644 { (char *)"DC_DrawIconPoint", (PyCFunction) _wrap_DC_DrawIconPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22645 { (char *)"DC_DrawBitmap", (PyCFunction) _wrap_DC_DrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22646 { (char *)"DC_DrawBitmapPoint", (PyCFunction) _wrap_DC_DrawBitmapPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22647 { (char *)"DC_DrawText", (PyCFunction) _wrap_DC_DrawText, METH_VARARGS | METH_KEYWORDS, NULL},
22648 { (char *)"DC_DrawTextPoint", (PyCFunction) _wrap_DC_DrawTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22649 { (char *)"DC_DrawRotatedText", (PyCFunction) _wrap_DC_DrawRotatedText, METH_VARARGS | METH_KEYWORDS, NULL},
22650 { (char *)"DC_DrawRotatedTextPoint", (PyCFunction) _wrap_DC_DrawRotatedTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22651 { (char *)"DC_Blit", (PyCFunction) _wrap_DC_Blit, METH_VARARGS | METH_KEYWORDS, NULL},
22652 { (char *)"DC_BlitPointSize", (PyCFunction) _wrap_DC_BlitPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
22653 { (char *)"DC_SetClippingRegion", (PyCFunction) _wrap_DC_SetClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
22654 { (char *)"DC_SetClippingRegionPointSize", (PyCFunction) _wrap_DC_SetClippingRegionPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
22655 { (char *)"DC_SetClippingRegionAsRegion", (PyCFunction) _wrap_DC_SetClippingRegionAsRegion, METH_VARARGS | METH_KEYWORDS, NULL},
22656 { (char *)"DC_SetClippingRect", (PyCFunction) _wrap_DC_SetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
22657 { (char *)"DC_DrawLines", (PyCFunction) _wrap_DC_DrawLines, METH_VARARGS | METH_KEYWORDS, NULL},
22658 { (char *)"DC_DrawPolygon", (PyCFunction) _wrap_DC_DrawPolygon, METH_VARARGS | METH_KEYWORDS, NULL},
22659 { (char *)"DC_DrawLabel", (PyCFunction) _wrap_DC_DrawLabel, METH_VARARGS | METH_KEYWORDS, NULL},
22660 { (char *)"DC_DrawImageLabel", (PyCFunction) _wrap_DC_DrawImageLabel, METH_VARARGS | METH_KEYWORDS, NULL},
22661 { (char *)"DC_DrawSpline", (PyCFunction) _wrap_DC_DrawSpline, METH_VARARGS | METH_KEYWORDS, NULL},
22662 { (char *)"DC_Clear", (PyCFunction) _wrap_DC_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
22663 { (char *)"DC_StartDoc", (PyCFunction) _wrap_DC_StartDoc, METH_VARARGS | METH_KEYWORDS, NULL},
22664 { (char *)"DC_EndDoc", (PyCFunction) _wrap_DC_EndDoc, METH_VARARGS | METH_KEYWORDS, NULL},
22665 { (char *)"DC_StartPage", (PyCFunction) _wrap_DC_StartPage, METH_VARARGS | METH_KEYWORDS, NULL},
22666 { (char *)"DC_EndPage", (PyCFunction) _wrap_DC_EndPage, METH_VARARGS | METH_KEYWORDS, NULL},
22667 { (char *)"DC_SetFont", (PyCFunction) _wrap_DC_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
22668 { (char *)"DC_SetPen", (PyCFunction) _wrap_DC_SetPen, METH_VARARGS | METH_KEYWORDS, NULL},
22669 { (char *)"DC_SetBrush", (PyCFunction) _wrap_DC_SetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
22670 { (char *)"DC_SetBackground", (PyCFunction) _wrap_DC_SetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
22671 { (char *)"DC_SetBackgroundMode", (PyCFunction) _wrap_DC_SetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
22672 { (char *)"DC_SetPalette", (PyCFunction) _wrap_DC_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
22673 { (char *)"DC_DestroyClippingRegion", (PyCFunction) _wrap_DC_DestroyClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
22674 { (char *)"DC_GetClippingBox", (PyCFunction) _wrap_DC_GetClippingBox, METH_VARARGS | METH_KEYWORDS, NULL},
22675 { (char *)"DC_GetClippingRect", (PyCFunction) _wrap_DC_GetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
22676 { (char *)"DC_GetCharHeight", (PyCFunction) _wrap_DC_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
22677 { (char *)"DC_GetCharWidth", (PyCFunction) _wrap_DC_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22678 { (char *)"DC_GetTextExtent", (PyCFunction) _wrap_DC_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
22679 { (char *)"DC_GetFullTextExtent", (PyCFunction) _wrap_DC_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
22680 { (char *)"DC_GetMultiLineTextExtent", (PyCFunction) _wrap_DC_GetMultiLineTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
22681 { (char *)"DC_GetPartialTextExtents", (PyCFunction) _wrap_DC_GetPartialTextExtents, METH_VARARGS | METH_KEYWORDS, NULL},
22682 { (char *)"DC_GetSize", (PyCFunction) _wrap_DC_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
22683 { (char *)"DC_GetSizeTuple", (PyCFunction) _wrap_DC_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
22684 { (char *)"DC_GetSizeMM", (PyCFunction) _wrap_DC_GetSizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
22685 { (char *)"DC_GetSizeMMTuple", (PyCFunction) _wrap_DC_GetSizeMMTuple, METH_VARARGS | METH_KEYWORDS, NULL},
22686 { (char *)"DC_DeviceToLogicalX", (PyCFunction) _wrap_DC_DeviceToLogicalX, METH_VARARGS | METH_KEYWORDS, NULL},
22687 { (char *)"DC_DeviceToLogicalY", (PyCFunction) _wrap_DC_DeviceToLogicalY, METH_VARARGS | METH_KEYWORDS, NULL},
22688 { (char *)"DC_DeviceToLogicalXRel", (PyCFunction) _wrap_DC_DeviceToLogicalXRel, METH_VARARGS | METH_KEYWORDS, NULL},
22689 { (char *)"DC_DeviceToLogicalYRel", (PyCFunction) _wrap_DC_DeviceToLogicalYRel, METH_VARARGS | METH_KEYWORDS, NULL},
22690 { (char *)"DC_LogicalToDeviceX", (PyCFunction) _wrap_DC_LogicalToDeviceX, METH_VARARGS | METH_KEYWORDS, NULL},
22691 { (char *)"DC_LogicalToDeviceY", (PyCFunction) _wrap_DC_LogicalToDeviceY, METH_VARARGS | METH_KEYWORDS, NULL},
22692 { (char *)"DC_LogicalToDeviceXRel", (PyCFunction) _wrap_DC_LogicalToDeviceXRel, METH_VARARGS | METH_KEYWORDS, NULL},
22693 { (char *)"DC_LogicalToDeviceYRel", (PyCFunction) _wrap_DC_LogicalToDeviceYRel, METH_VARARGS | METH_KEYWORDS, NULL},
22694 { (char *)"DC_CanDrawBitmap", (PyCFunction) _wrap_DC_CanDrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22695 { (char *)"DC_CanGetTextExtent", (PyCFunction) _wrap_DC_CanGetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
22696 { (char *)"DC_GetDepth", (PyCFunction) _wrap_DC_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
22697 { (char *)"DC_GetPPI", (PyCFunction) _wrap_DC_GetPPI, METH_VARARGS | METH_KEYWORDS, NULL},
22698 { (char *)"DC_Ok", (PyCFunction) _wrap_DC_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
22699 { (char *)"DC_GetBackgroundMode", (PyCFunction) _wrap_DC_GetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
22700 { (char *)"DC_GetBackground", (PyCFunction) _wrap_DC_GetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
22701 { (char *)"DC_GetBrush", (PyCFunction) _wrap_DC_GetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
22702 { (char *)"DC_GetFont", (PyCFunction) _wrap_DC_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
22703 { (char *)"DC_GetPen", (PyCFunction) _wrap_DC_GetPen, METH_VARARGS | METH_KEYWORDS, NULL},
22704 { (char *)"DC_GetTextBackground", (PyCFunction) _wrap_DC_GetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
22705 { (char *)"DC_GetTextForeground", (PyCFunction) _wrap_DC_GetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
22706 { (char *)"DC_SetTextForeground", (PyCFunction) _wrap_DC_SetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
22707 { (char *)"DC_SetTextBackground", (PyCFunction) _wrap_DC_SetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
22708 { (char *)"DC_GetMapMode", (PyCFunction) _wrap_DC_GetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
22709 { (char *)"DC_SetMapMode", (PyCFunction) _wrap_DC_SetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
22710 { (char *)"DC_GetUserScale", (PyCFunction) _wrap_DC_GetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
22711 { (char *)"DC_SetUserScale", (PyCFunction) _wrap_DC_SetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
22712 { (char *)"DC_GetLogicalScale", (PyCFunction) _wrap_DC_GetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
22713 { (char *)"DC_SetLogicalScale", (PyCFunction) _wrap_DC_SetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
22714 { (char *)"DC_GetLogicalOrigin", (PyCFunction) _wrap_DC_GetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
22715 { (char *)"DC_GetLogicalOriginTuple", (PyCFunction) _wrap_DC_GetLogicalOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
22716 { (char *)"DC_SetLogicalOrigin", (PyCFunction) _wrap_DC_SetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
22717 { (char *)"DC_SetLogicalOriginPoint", (PyCFunction) _wrap_DC_SetLogicalOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22718 { (char *)"DC_GetDeviceOrigin", (PyCFunction) _wrap_DC_GetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
22719 { (char *)"DC_GetDeviceOriginTuple", (PyCFunction) _wrap_DC_GetDeviceOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
22720 { (char *)"DC_SetDeviceOrigin", (PyCFunction) _wrap_DC_SetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
22721 { (char *)"DC_SetDeviceOriginPoint", (PyCFunction) _wrap_DC_SetDeviceOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22722 { (char *)"DC_SetAxisOrientation", (PyCFunction) _wrap_DC_SetAxisOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
22723 { (char *)"DC_GetLogicalFunction", (PyCFunction) _wrap_DC_GetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
22724 { (char *)"DC_SetLogicalFunction", (PyCFunction) _wrap_DC_SetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
22725 { (char *)"DC_ComputeScaleAndOrigin", (PyCFunction) _wrap_DC_ComputeScaleAndOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
22726 { (char *)"DC_CalcBoundingBox", (PyCFunction) _wrap_DC_CalcBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
22727 { (char *)"DC_CalcBoundingBoxPoint", (PyCFunction) _wrap_DC_CalcBoundingBoxPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22728 { (char *)"DC_ResetBoundingBox", (PyCFunction) _wrap_DC_ResetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
22729 { (char *)"DC_MinX", (PyCFunction) _wrap_DC_MinX, METH_VARARGS | METH_KEYWORDS, NULL},
22730 { (char *)"DC_MaxX", (PyCFunction) _wrap_DC_MaxX, METH_VARARGS | METH_KEYWORDS, NULL},
22731 { (char *)"DC_MinY", (PyCFunction) _wrap_DC_MinY, METH_VARARGS | METH_KEYWORDS, NULL},
22732 { (char *)"DC_MaxY", (PyCFunction) _wrap_DC_MaxY, METH_VARARGS | METH_KEYWORDS, NULL},
22733 { (char *)"DC_GetBoundingBox", (PyCFunction) _wrap_DC_GetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
22734 { (char *)"DC_GetHDC", (PyCFunction) _wrap_DC_GetHDC, METH_VARARGS | METH_KEYWORDS, NULL},
22735 { (char *)"DC__DrawPointList", (PyCFunction) _wrap_DC__DrawPointList, METH_VARARGS | METH_KEYWORDS, NULL},
22736 { (char *)"DC__DrawLineList", (PyCFunction) _wrap_DC__DrawLineList, METH_VARARGS | METH_KEYWORDS, NULL},
22737 { (char *)"DC__DrawRectangleList", (PyCFunction) _wrap_DC__DrawRectangleList, METH_VARARGS | METH_KEYWORDS, NULL},
22738 { (char *)"DC__DrawEllipseList", (PyCFunction) _wrap_DC__DrawEllipseList, METH_VARARGS | METH_KEYWORDS, NULL},
22739 { (char *)"DC__DrawPolygonList", (PyCFunction) _wrap_DC__DrawPolygonList, METH_VARARGS | METH_KEYWORDS, NULL},
22740 { (char *)"DC__DrawTextList", (PyCFunction) _wrap_DC__DrawTextList, METH_VARARGS | METH_KEYWORDS, NULL},
22741 { (char *)"DC_swigregister", DC_swigregister, METH_VARARGS, NULL},
22742 { (char *)"new_MemoryDC", (PyCFunction) _wrap_new_MemoryDC, METH_VARARGS | METH_KEYWORDS, NULL},
22743 { (char *)"new_MemoryDCFromDC", (PyCFunction) _wrap_new_MemoryDCFromDC, METH_VARARGS | METH_KEYWORDS, NULL},
22744 { (char *)"MemoryDC_SelectObject", (PyCFunction) _wrap_MemoryDC_SelectObject, METH_VARARGS | METH_KEYWORDS, NULL},
22745 { (char *)"MemoryDC_swigregister", MemoryDC_swigregister, METH_VARARGS, NULL},
22746 { (char *)"new_BufferedDC", _wrap_new_BufferedDC, METH_VARARGS, NULL},
22747 { (char *)"delete_BufferedDC", (PyCFunction) _wrap_delete_BufferedDC, METH_VARARGS | METH_KEYWORDS, NULL},
22748 { (char *)"BufferedDC_UnMask", (PyCFunction) _wrap_BufferedDC_UnMask, METH_VARARGS | METH_KEYWORDS, NULL},
22749 { (char *)"BufferedDC_swigregister", BufferedDC_swigregister, METH_VARARGS, NULL},
22750 { (char *)"new_BufferedPaintDC", (PyCFunction) _wrap_new_BufferedPaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
22751 { (char *)"BufferedPaintDC_swigregister", BufferedPaintDC_swigregister, METH_VARARGS, NULL},
22752 { (char *)"new_ScreenDC", (PyCFunction) _wrap_new_ScreenDC, METH_VARARGS | METH_KEYWORDS, NULL},
22753 { (char *)"ScreenDC_StartDrawingOnTopWin", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTopWin, METH_VARARGS | METH_KEYWORDS, NULL},
22754 { (char *)"ScreenDC_StartDrawingOnTop", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
22755 { (char *)"ScreenDC_EndDrawingOnTop", (PyCFunction) _wrap_ScreenDC_EndDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
22756 { (char *)"ScreenDC_swigregister", ScreenDC_swigregister, METH_VARARGS, NULL},
22757 { (char *)"new_ClientDC", (PyCFunction) _wrap_new_ClientDC, METH_VARARGS | METH_KEYWORDS, NULL},
22758 { (char *)"ClientDC_swigregister", ClientDC_swigregister, METH_VARARGS, NULL},
22759 { (char *)"new_PaintDC", (PyCFunction) _wrap_new_PaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
22760 { (char *)"PaintDC_swigregister", PaintDC_swigregister, METH_VARARGS, NULL},
22761 { (char *)"new_WindowDC", (PyCFunction) _wrap_new_WindowDC, METH_VARARGS | METH_KEYWORDS, NULL},
22762 { (char *)"WindowDC_swigregister", WindowDC_swigregister, METH_VARARGS, NULL},
22763 { (char *)"new_MirrorDC", (PyCFunction) _wrap_new_MirrorDC, METH_VARARGS | METH_KEYWORDS, NULL},
22764 { (char *)"MirrorDC_swigregister", MirrorDC_swigregister, METH_VARARGS, NULL},
22765 { (char *)"new_PostScriptDC", (PyCFunction) _wrap_new_PostScriptDC, METH_VARARGS | METH_KEYWORDS, NULL},
22766 { (char *)"PostScriptDC_GetPrintData", (PyCFunction) _wrap_PostScriptDC_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
22767 { (char *)"PostScriptDC_SetPrintData", (PyCFunction) _wrap_PostScriptDC_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
22768 { (char *)"PostScriptDC_SetResolution", (PyCFunction) _wrap_PostScriptDC_SetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
22769 { (char *)"PostScriptDC_GetResolution", (PyCFunction) _wrap_PostScriptDC_GetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
22770 { (char *)"PostScriptDC_swigregister", PostScriptDC_swigregister, METH_VARARGS, NULL},
22771 { (char *)"new_MetaFile", (PyCFunction) _wrap_new_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
22772 { (char *)"delete_MetaFile", (PyCFunction) _wrap_delete_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
22773 { (char *)"MetaFile_Ok", (PyCFunction) _wrap_MetaFile_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
22774 { (char *)"MetaFile_SetClipboard", (PyCFunction) _wrap_MetaFile_SetClipboard, METH_VARARGS | METH_KEYWORDS, NULL},
22775 { (char *)"MetaFile_GetSize", (PyCFunction) _wrap_MetaFile_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
22776 { (char *)"MetaFile_GetWidth", (PyCFunction) _wrap_MetaFile_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22777 { (char *)"MetaFile_GetHeight", (PyCFunction) _wrap_MetaFile_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
22778 { (char *)"MetaFile_GetFileName", (PyCFunction) _wrap_MetaFile_GetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
22779 { (char *)"MetaFile_swigregister", MetaFile_swigregister, METH_VARARGS, NULL},
22780 { (char *)"new_MetaFileDC", (PyCFunction) _wrap_new_MetaFileDC, METH_VARARGS | METH_KEYWORDS, NULL},
22781 { (char *)"MetaFileDC_Close", (PyCFunction) _wrap_MetaFileDC_Close, METH_VARARGS | METH_KEYWORDS, NULL},
22782 { (char *)"MetaFileDC_swigregister", MetaFileDC_swigregister, METH_VARARGS, NULL},
22783 { (char *)"new_PrinterDC", (PyCFunction) _wrap_new_PrinterDC, METH_VARARGS | METH_KEYWORDS, NULL},
22784 { (char *)"PrinterDC_swigregister", PrinterDC_swigregister, METH_VARARGS, NULL},
22785 { (char *)"new_ImageList", (PyCFunction) _wrap_new_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
22786 { (char *)"delete_ImageList", (PyCFunction) _wrap_delete_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
22787 { (char *)"ImageList_Add", (PyCFunction) _wrap_ImageList_Add, METH_VARARGS | METH_KEYWORDS, NULL},
22788 { (char *)"ImageList_AddWithColourMask", (PyCFunction) _wrap_ImageList_AddWithColourMask, METH_VARARGS | METH_KEYWORDS, NULL},
22789 { (char *)"ImageList_AddIcon", (PyCFunction) _wrap_ImageList_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
22790 { (char *)"ImageList_GetBitmap", (PyCFunction) _wrap_ImageList_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22791 { (char *)"ImageList_GetIcon", (PyCFunction) _wrap_ImageList_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
22792 { (char *)"ImageList_Replace", (PyCFunction) _wrap_ImageList_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
22793 { (char *)"ImageList_Draw", (PyCFunction) _wrap_ImageList_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
22794 { (char *)"ImageList_GetImageCount", (PyCFunction) _wrap_ImageList_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
22795 { (char *)"ImageList_Remove", (PyCFunction) _wrap_ImageList_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
22796 { (char *)"ImageList_RemoveAll", (PyCFunction) _wrap_ImageList_RemoveAll, METH_VARARGS | METH_KEYWORDS, NULL},
22797 { (char *)"ImageList_GetSize", (PyCFunction) _wrap_ImageList_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
22798 { (char *)"ImageList_swigregister", ImageList_swigregister, METH_VARARGS, NULL},
22799 { (char *)"PenList_AddPen", (PyCFunction) _wrap_PenList_AddPen, METH_VARARGS | METH_KEYWORDS, NULL},
22800 { (char *)"PenList_FindOrCreatePen", (PyCFunction) _wrap_PenList_FindOrCreatePen, METH_VARARGS | METH_KEYWORDS, NULL},
22801 { (char *)"PenList_RemovePen", (PyCFunction) _wrap_PenList_RemovePen, METH_VARARGS | METH_KEYWORDS, NULL},
22802 { (char *)"PenList_GetCount", (PyCFunction) _wrap_PenList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
22803 { (char *)"PenList_swigregister", PenList_swigregister, METH_VARARGS, NULL},
22804 { (char *)"BrushList_AddBrush", (PyCFunction) _wrap_BrushList_AddBrush, METH_VARARGS | METH_KEYWORDS, NULL},
22805 { (char *)"BrushList_FindOrCreateBrush", (PyCFunction) _wrap_BrushList_FindOrCreateBrush, METH_VARARGS | METH_KEYWORDS, NULL},
22806 { (char *)"BrushList_RemoveBrush", (PyCFunction) _wrap_BrushList_RemoveBrush, METH_VARARGS | METH_KEYWORDS, NULL},
22807 { (char *)"BrushList_GetCount", (PyCFunction) _wrap_BrushList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
22808 { (char *)"BrushList_swigregister", BrushList_swigregister, METH_VARARGS, NULL},
22809 { (char *)"new_ColourDatabase", (PyCFunction) _wrap_new_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
22810 { (char *)"delete_ColourDatabase", (PyCFunction) _wrap_delete_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
22811 { (char *)"ColourDatabase_Find", (PyCFunction) _wrap_ColourDatabase_Find, METH_VARARGS | METH_KEYWORDS, NULL},
22812 { (char *)"ColourDatabase_FindName", (PyCFunction) _wrap_ColourDatabase_FindName, METH_VARARGS | METH_KEYWORDS, NULL},
22813 { (char *)"ColourDatabase_AddColour", (PyCFunction) _wrap_ColourDatabase_AddColour, METH_VARARGS | METH_KEYWORDS, NULL},
22814 { (char *)"ColourDatabase_Append", (PyCFunction) _wrap_ColourDatabase_Append, METH_VARARGS | METH_KEYWORDS, NULL},
22815 { (char *)"ColourDatabase_swigregister", ColourDatabase_swigregister, METH_VARARGS, NULL},
22816 { (char *)"FontList_AddFont", (PyCFunction) _wrap_FontList_AddFont, METH_VARARGS | METH_KEYWORDS, NULL},
22817 { (char *)"FontList_FindOrCreateFont", (PyCFunction) _wrap_FontList_FindOrCreateFont, METH_VARARGS | METH_KEYWORDS, NULL},
22818 { (char *)"FontList_RemoveFont", (PyCFunction) _wrap_FontList_RemoveFont, METH_VARARGS | METH_KEYWORDS, NULL},
22819 { (char *)"FontList_GetCount", (PyCFunction) _wrap_FontList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
22820 { (char *)"FontList_swigregister", FontList_swigregister, METH_VARARGS, NULL},
22821 { (char *)"new_Effects", (PyCFunction) _wrap_new_Effects, METH_VARARGS | METH_KEYWORDS, NULL},
22822 { (char *)"Effects_GetHighlightColour", (PyCFunction) _wrap_Effects_GetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
22823 { (char *)"Effects_GetLightShadow", (PyCFunction) _wrap_Effects_GetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22824 { (char *)"Effects_GetFaceColour", (PyCFunction) _wrap_Effects_GetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
22825 { (char *)"Effects_GetMediumShadow", (PyCFunction) _wrap_Effects_GetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22826 { (char *)"Effects_GetDarkShadow", (PyCFunction) _wrap_Effects_GetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22827 { (char *)"Effects_SetHighlightColour", (PyCFunction) _wrap_Effects_SetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
22828 { (char *)"Effects_SetLightShadow", (PyCFunction) _wrap_Effects_SetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22829 { (char *)"Effects_SetFaceColour", (PyCFunction) _wrap_Effects_SetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
22830 { (char *)"Effects_SetMediumShadow", (PyCFunction) _wrap_Effects_SetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22831 { (char *)"Effects_SetDarkShadow", (PyCFunction) _wrap_Effects_SetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22832 { (char *)"Effects_Set", (PyCFunction) _wrap_Effects_Set, METH_VARARGS | METH_KEYWORDS, NULL},
22833 { (char *)"Effects_DrawSunkenEdge", (PyCFunction) _wrap_Effects_DrawSunkenEdge, METH_VARARGS | METH_KEYWORDS, NULL},
22834 { (char *)"Effects_TileBitmap", (PyCFunction) _wrap_Effects_TileBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22835 { (char *)"Effects_swigregister", Effects_swigregister, METH_VARARGS, NULL},
22836 { (char *)"new_SplitterRenderParams", (PyCFunction) _wrap_new_SplitterRenderParams, METH_VARARGS | METH_KEYWORDS, NULL},
22837 { (char *)"delete_SplitterRenderParams", (PyCFunction) _wrap_delete_SplitterRenderParams, METH_VARARGS | METH_KEYWORDS, NULL},
22838 { (char *)"SplitterRenderParams_widthSash_get", (PyCFunction) _wrap_SplitterRenderParams_widthSash_get, METH_VARARGS | METH_KEYWORDS, NULL},
22839 { (char *)"SplitterRenderParams_border_get", (PyCFunction) _wrap_SplitterRenderParams_border_get, METH_VARARGS | METH_KEYWORDS, NULL},
22840 { (char *)"SplitterRenderParams_isHotSensitive_get", (PyCFunction) _wrap_SplitterRenderParams_isHotSensitive_get, METH_VARARGS | METH_KEYWORDS, NULL},
22841 { (char *)"SplitterRenderParams_swigregister", SplitterRenderParams_swigregister, METH_VARARGS, NULL},
22842 { (char *)"new_RendererVersion", (PyCFunction) _wrap_new_RendererVersion, METH_VARARGS | METH_KEYWORDS, NULL},
22843 { (char *)"delete_RendererVersion", (PyCFunction) _wrap_delete_RendererVersion, METH_VARARGS | METH_KEYWORDS, NULL},
22844 { (char *)"RendererVersion_IsCompatible", (PyCFunction) _wrap_RendererVersion_IsCompatible, METH_VARARGS | METH_KEYWORDS, NULL},
22845 { (char *)"RendererVersion_version_get", (PyCFunction) _wrap_RendererVersion_version_get, METH_VARARGS | METH_KEYWORDS, NULL},
22846 { (char *)"RendererVersion_age_get", (PyCFunction) _wrap_RendererVersion_age_get, METH_VARARGS | METH_KEYWORDS, NULL},
22847 { (char *)"RendererVersion_swigregister", RendererVersion_swigregister, METH_VARARGS, NULL},
22848 { (char *)"RendererNative_DrawHeaderButton", (PyCFunction) _wrap_RendererNative_DrawHeaderButton, METH_VARARGS | METH_KEYWORDS, NULL},
22849 { (char *)"RendererNative_DrawTreeItemButton", (PyCFunction) _wrap_RendererNative_DrawTreeItemButton, METH_VARARGS | METH_KEYWORDS, NULL},
22850 { (char *)"RendererNative_DrawSplitterBorder", (PyCFunction) _wrap_RendererNative_DrawSplitterBorder, METH_VARARGS | METH_KEYWORDS, NULL},
22851 { (char *)"RendererNative_DrawSplitterSash", (PyCFunction) _wrap_RendererNative_DrawSplitterSash, METH_VARARGS | METH_KEYWORDS, NULL},
22852 { (char *)"RendererNative_DrawComboBoxDropButton", (PyCFunction) _wrap_RendererNative_DrawComboBoxDropButton, METH_VARARGS | METH_KEYWORDS, NULL},
22853 { (char *)"RendererNative_DrawDropArrow", (PyCFunction) _wrap_RendererNative_DrawDropArrow, METH_VARARGS | METH_KEYWORDS, NULL},
22854 { (char *)"RendererNative_GetSplitterParams", (PyCFunction) _wrap_RendererNative_GetSplitterParams, METH_VARARGS | METH_KEYWORDS, NULL},
22855 { (char *)"RendererNative_Get", (PyCFunction) _wrap_RendererNative_Get, METH_VARARGS | METH_KEYWORDS, NULL},
22856 { (char *)"RendererNative_GetGeneric", (PyCFunction) _wrap_RendererNative_GetGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
22857 { (char *)"RendererNative_GetDefault", (PyCFunction) _wrap_RendererNative_GetDefault, METH_VARARGS | METH_KEYWORDS, NULL},
22858 { (char *)"RendererNative_Set", (PyCFunction) _wrap_RendererNative_Set, METH_VARARGS | METH_KEYWORDS, NULL},
22859 { (char *)"RendererNative_GetVersion", (PyCFunction) _wrap_RendererNative_GetVersion, METH_VARARGS | METH_KEYWORDS, NULL},
22860 { (char *)"RendererNative_swigregister", RendererNative_swigregister, METH_VARARGS, NULL},
22861 { NULL, NULL, 0, NULL }
22862 };
22863
22864
22865 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
22866
22867 static void *_p_wxBufferedDCTo_p_wxMemoryDC(void *x) {
22868 return (void *)((wxMemoryDC *) ((wxBufferedDC *) x));
22869 }
22870 static void *_p_wxBufferedPaintDCTo_p_wxMemoryDC(void *x) {
22871 return (void *)((wxMemoryDC *) (wxBufferedDC *) ((wxBufferedPaintDC *) x));
22872 }
22873 static void *_p_wxIconTo_p_wxGDIObject(void *x) {
22874 return (void *)((wxGDIObject *) ((wxIcon *) x));
22875 }
22876 static void *_p_wxPaletteTo_p_wxGDIObject(void *x) {
22877 return (void *)((wxGDIObject *) ((wxPalette *) x));
22878 }
22879 static void *_p_wxPenTo_p_wxGDIObject(void *x) {
22880 return (void *)((wxGDIObject *) ((wxPen *) x));
22881 }
22882 static void *_p_wxFontTo_p_wxGDIObject(void *x) {
22883 return (void *)((wxGDIObject *) ((wxFont *) x));
22884 }
22885 static void *_p_wxCursorTo_p_wxGDIObject(void *x) {
22886 return (void *)((wxGDIObject *) ((wxCursor *) x));
22887 }
22888 static void *_p_wxBitmapTo_p_wxGDIObject(void *x) {
22889 return (void *)((wxGDIObject *) ((wxBitmap *) x));
22890 }
22891 static void *_p_wxRegionTo_p_wxGDIObject(void *x) {
22892 return (void *)((wxGDIObject *) ((wxRegion *) x));
22893 }
22894 static void *_p_wxBrushTo_p_wxGDIObject(void *x) {
22895 return (void *)((wxGDIObject *) ((wxBrush *) x));
22896 }
22897 static void *_p_wxBufferedDCTo_p_wxDC(void *x) {
22898 return (void *)((wxDC *) (wxMemoryDC *) ((wxBufferedDC *) x));
22899 }
22900 static void *_p_wxScreenDCTo_p_wxDC(void *x) {
22901 return (void *)((wxDC *) ((wxScreenDC *) x));
22902 }
22903 static void *_p_wxMirrorDCTo_p_wxDC(void *x) {
22904 return (void *)((wxDC *) ((wxMirrorDC *) x));
22905 }
22906 static void *_p_wxMemoryDCTo_p_wxDC(void *x) {
22907 return (void *)((wxDC *) ((wxMemoryDC *) x));
22908 }
22909 static void *_p_wxWindowDCTo_p_wxDC(void *x) {
22910 return (void *)((wxDC *) ((wxWindowDC *) x));
22911 }
22912 static void *_p_wxMetaFileDCTo_p_wxDC(void *x) {
22913 return (void *)((wxDC *) ((wxMetaFileDC *) x));
22914 }
22915 static void *_p_wxBufferedPaintDCTo_p_wxDC(void *x) {
22916 return (void *)((wxDC *) (wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
22917 }
22918 static void *_p_wxClientDCTo_p_wxDC(void *x) {
22919 return (void *)((wxDC *) ((wxClientDC *) x));
22920 }
22921 static void *_p_wxPaintDCTo_p_wxDC(void *x) {
22922 return (void *)((wxDC *) ((wxPaintDC *) x));
22923 }
22924 static void *_p_wxPostScriptDCTo_p_wxDC(void *x) {
22925 return (void *)((wxDC *) ((wxPostScriptDC *) x));
22926 }
22927 static void *_p_wxPrinterDCTo_p_wxDC(void *x) {
22928 return (void *)((wxDC *) ((wxPrinterDC *) x));
22929 }
22930 static void *_p_wxBufferedPaintDCTo_p_wxBufferedDC(void *x) {
22931 return (void *)((wxBufferedDC *) ((wxBufferedPaintDC *) x));
22932 }
22933 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
22934 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
22935 }
22936 static void *_p_wxPenTo_p_wxObject(void *x) {
22937 return (void *)((wxObject *) (wxGDIObject *) ((wxPen *) x));
22938 }
22939 static void *_p_wxRegionIteratorTo_p_wxObject(void *x) {
22940 return (void *)((wxObject *) ((wxRegionIterator *) x));
22941 }
22942 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
22943 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
22944 }
22945 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
22946 return (void *)((wxObject *) ((wxSizerItem *) x));
22947 }
22948 static void *_p_wxColourDatabaseTo_p_wxObject(void *x) {
22949 return (void *)((wxObject *) ((wxColourDatabase *) x));
22950 }
22951 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
22952 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
22953 }
22954 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
22955 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
22956 }
22957 static void *_p_wxIconTo_p_wxObject(void *x) {
22958 return (void *)((wxObject *) (wxGDIObject *) ((wxIcon *) x));
22959 }
22960 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
22961 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
22962 }
22963 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
22964 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
22965 }
22966 static void *_p_wxSizerTo_p_wxObject(void *x) {
22967 return (void *)((wxObject *) ((wxSizer *) x));
22968 }
22969 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
22970 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
22971 }
22972 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
22973 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
22974 }
22975 static void *_p_wxPenListTo_p_wxObject(void *x) {
22976 return (void *)((wxObject *) ((wxPenList *) x));
22977 }
22978 static void *_p_wxEventTo_p_wxObject(void *x) {
22979 return (void *)((wxObject *) ((wxEvent *) x));
22980 }
22981 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
22982 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
22983 }
22984 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
22985 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
22986 }
22987 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
22988 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
22989 }
22990 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
22991 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
22992 }
22993 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
22994 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
22995 }
22996 static void *_p_wxDCTo_p_wxObject(void *x) {
22997 return (void *)((wxObject *) ((wxDC *) x));
22998 }
22999 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
23000 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
23001 }
23002 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
23003 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
23004 }
23005 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
23006 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
23007 }
23008 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
23009 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
23010 }
23011 static void *_p_wxControlTo_p_wxObject(void *x) {
23012 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
23013 }
23014 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
23015 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
23016 }
23017 static void *_p_wxClientDCTo_p_wxObject(void *x) {
23018 return (void *)((wxObject *) (wxDC *) ((wxClientDC *) x));
23019 }
23020 static void *_p_wxFSFileTo_p_wxObject(void *x) {
23021 return (void *)((wxObject *) ((wxFSFile *) x));
23022 }
23023 static void *_p_wxMemoryDCTo_p_wxObject(void *x) {
23024 return (void *)((wxObject *) (wxDC *) ((wxMemoryDC *) x));
23025 }
23026 static void *_p_wxRegionTo_p_wxObject(void *x) {
23027 return (void *)((wxObject *) (wxGDIObject *) ((wxRegion *) x));
23028 }
23029 static void *_p_wxPySizerTo_p_wxObject(void *x) {
23030 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
23031 }
23032 static void *_p_wxWindowDCTo_p_wxObject(void *x) {
23033 return (void *)((wxObject *) (wxDC *) ((wxWindowDC *) x));
23034 }
23035 static void *_p_wxGDIObjectTo_p_wxObject(void *x) {
23036 return (void *)((wxObject *) ((wxGDIObject *) x));
23037 }
23038 static void *_p_wxEffectsTo_p_wxObject(void *x) {
23039 return (void *)((wxObject *) ((wxEffects *) x));
23040 }
23041 static void *_p_wxPyEventTo_p_wxObject(void *x) {
23042 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
23043 }
23044 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
23045 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
23046 }
23047 static void *_p_wxPostScriptDCTo_p_wxObject(void *x) {
23048 return (void *)((wxObject *) (wxDC *) ((wxPostScriptDC *) x));
23049 }
23050 static void *_p_wxShowEventTo_p_wxObject(void *x) {
23051 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
23052 }
23053 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
23054 return (void *)((wxObject *) ((wxMenuItem *) x));
23055 }
23056 static void *_p_wxDateEventTo_p_wxObject(void *x) {
23057 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
23058 }
23059 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
23060 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
23061 }
23062 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
23063 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
23064 }
23065 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
23066 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
23067 }
23068 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
23069 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
23070 }
23071 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
23072 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
23073 }
23074 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
23075 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
23076 }
23077 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
23078 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
23079 }
23080 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
23081 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
23082 }
23083 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
23084 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
23085 }
23086 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
23087 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
23088 }
23089 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
23090 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
23091 }
23092 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
23093 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
23094 }
23095 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
23096 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
23097 }
23098 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
23099 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
23100 }
23101 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
23102 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
23103 }
23104 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
23105 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
23106 }
23107 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
23108 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
23109 }
23110 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
23111 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
23112 }
23113 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
23114 return (void *)((wxObject *) ((wxImageHandler *) x));
23115 }
23116 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
23117 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
23118 }
23119 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
23120 return (void *)((wxObject *) ((wxEvtHandler *) x));
23121 }
23122 static void *_p_wxBufferedPaintDCTo_p_wxObject(void *x) {
23123 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
23124 }
23125 static void *_p_wxPaintDCTo_p_wxObject(void *x) {
23126 return (void *)((wxObject *) (wxDC *) ((wxPaintDC *) x));
23127 }
23128 static void *_p_wxPrinterDCTo_p_wxObject(void *x) {
23129 return (void *)((wxObject *) (wxDC *) ((wxPrinterDC *) x));
23130 }
23131 static void *_p_wxScreenDCTo_p_wxObject(void *x) {
23132 return (void *)((wxObject *) (wxDC *) ((wxScreenDC *) x));
23133 }
23134 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
23135 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
23136 }
23137 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
23138 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
23139 }
23140 static void *_p_wxImageTo_p_wxObject(void *x) {
23141 return (void *)((wxObject *) ((wxImage *) x));
23142 }
23143 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
23144 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
23145 }
23146 static void *_p_wxPaletteTo_p_wxObject(void *x) {
23147 return (void *)((wxObject *) (wxGDIObject *) ((wxPalette *) x));
23148 }
23149 static void *_p_wxBufferedDCTo_p_wxObject(void *x) {
23150 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *) ((wxBufferedDC *) x));
23151 }
23152 static void *_p_wxImageListTo_p_wxObject(void *x) {
23153 return (void *)((wxObject *) ((wxImageList *) x));
23154 }
23155 static void *_p_wxCursorTo_p_wxObject(void *x) {
23156 return (void *)((wxObject *) (wxGDIObject *) ((wxCursor *) x));
23157 }
23158 static void *_p_wxEncodingConverterTo_p_wxObject(void *x) {
23159 return (void *)((wxObject *) ((wxEncodingConverter *) x));
23160 }
23161 static void *_p_wxMirrorDCTo_p_wxObject(void *x) {
23162 return (void *)((wxObject *) (wxDC *) ((wxMirrorDC *) x));
23163 }
23164 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
23165 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
23166 }
23167 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
23168 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
23169 }
23170 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
23171 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
23172 }
23173 static void *_p_wxWindowTo_p_wxObject(void *x) {
23174 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
23175 }
23176 static void *_p_wxMenuTo_p_wxObject(void *x) {
23177 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
23178 }
23179 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
23180 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
23181 }
23182 static void *_p_wxMetaFileDCTo_p_wxObject(void *x) {
23183 return (void *)((wxObject *) (wxDC *) ((wxMetaFileDC *) x));
23184 }
23185 static void *_p_wxBrushListTo_p_wxObject(void *x) {
23186 return (void *)((wxObject *) ((wxBrushList *) x));
23187 }
23188 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
23189 return (void *)((wxObject *) ((wxFileSystem *) x));
23190 }
23191 static void *_p_wxBitmapTo_p_wxObject(void *x) {
23192 return (void *)((wxObject *) (wxGDIObject *) ((wxBitmap *) x));
23193 }
23194 static void *_p_wxMaskTo_p_wxObject(void *x) {
23195 return (void *)((wxObject *) ((wxMask *) x));
23196 }
23197 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
23198 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
23199 }
23200 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
23201 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
23202 }
23203 static void *_p_wxPyAppTo_p_wxObject(void *x) {
23204 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
23205 }
23206 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
23207 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
23208 }
23209 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
23210 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
23211 }
23212 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
23213 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
23214 }
23215 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
23216 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
23217 }
23218 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
23219 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
23220 }
23221 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
23222 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
23223 }
23224 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
23225 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
23226 }
23227 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
23228 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
23229 }
23230 static void *_p_wxFontTo_p_wxObject(void *x) {
23231 return (void *)((wxObject *) (wxGDIObject *) ((wxFont *) x));
23232 }
23233 static void *_p_wxBrushTo_p_wxObject(void *x) {
23234 return (void *)((wxObject *) (wxGDIObject *) ((wxBrush *) x));
23235 }
23236 static void *_p_wxMetaFileTo_p_wxObject(void *x) {
23237 return (void *)((wxObject *) ((wxMetaFile *) x));
23238 }
23239 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
23240 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
23241 }
23242 static void *_p_wxColourTo_p_wxObject(void *x) {
23243 return (void *)((wxObject *) ((wxColour *) x));
23244 }
23245 static void *_p_wxFontListTo_p_wxObject(void *x) {
23246 return (void *)((wxObject *) ((wxFontList *) x));
23247 }
23248 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
23249 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
23250 }
23251 static void *_p_wxValidatorTo_p_wxObject(void *x) {
23252 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
23253 }
23254 static void *_p_wxControlTo_p_wxWindow(void *x) {
23255 return (void *)((wxWindow *) ((wxControl *) x));
23256 }
23257 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
23258 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
23259 }
23260 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
23261 return (void *)((wxWindow *) ((wxMenuBar *) x));
23262 }
23263 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}};
23264 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}};
23265 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}};
23266 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}};
23267 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}};
23268 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}};
23269 static swig_type_info _swigt__p_wxRendererVersion[] = {{"_p_wxRendererVersion", 0, "wxRendererVersion *", 0, 0, 0, 0},{"_p_wxRendererVersion", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23270 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}};
23271 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}};
23272 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}};
23273 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}};
23274 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}};
23275 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}};
23276 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}};
23277 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}};
23278 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}};
23279 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}};
23280 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}};
23281 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}};
23282 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}};
23283 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}};
23284 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}};
23285 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}};
23286 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}};
23287 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxRegionIterator", _p_wxRegionIteratorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPen", _p_wxPenTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxColourDatabase", _p_wxColourDatabaseTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPenList", _p_wxPenListTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMask", _p_wxMaskTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFont", _p_wxFontTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxClientDC", _p_wxClientDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMemoryDC", _p_wxMemoryDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxRegion", _p_wxRegionTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDC", _p_wxDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIcon", _p_wxIconTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDC", _p_wxWindowDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGDIObject", _p_wxGDIObjectTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEffects", _p_wxEffectsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPostScriptDC", _p_wxPostScriptDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintDC", _p_wxPaintDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBufferedPaintDC", _p_wxBufferedPaintDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPrinterDC", _p_wxPrinterDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScreenDC", _p_wxScreenDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBufferedDC", _p_wxBufferedDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPalette", _p_wxPaletteTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageList", _p_wxImageListTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCursor", _p_wxCursorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxMirrorDC", _p_wxMirrorDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEncodingConverter", _p_wxEncodingConverterTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMetaFileDC", _p_wxMetaFileDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBrushList", _p_wxBrushListTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBitmap", _p_wxBitmapTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBrush", _p_wxBrushTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMetaFile", _p_wxMetaFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxColour", _p_wxColourTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFontList", _p_wxFontListTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23288 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}};
23289 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}};
23290 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}};
23291 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}};
23292 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}};
23293 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}};
23294 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}};
23295 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}};
23296 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}};
23297 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}};
23298 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}};
23299 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}};
23300 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}};
23301 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}};
23302 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}};
23303 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}};
23304 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}};
23305 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}};
23306 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}};
23307 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}};
23308 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}};
23309 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}};
23310 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}};
23311 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}};
23312 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}};
23313 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}};
23314 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}};
23315 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}};
23316 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}};
23317 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}};
23318 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}};
23319 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}};
23320 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}};
23321 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}};
23322 static swig_type_info _swigt__p_wxRendererNative[] = {{"_p_wxRendererNative", 0, "wxRendererNative *", 0, 0, 0, 0},{"_p_wxRendererNative", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23323 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}};
23324 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}};
23325 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}};
23326 static swig_type_info _swigt__p_wxSplitterRenderParams[] = {{"_p_wxSplitterRenderParams", 0, "wxSplitterRenderParams *", 0, 0, 0, 0},{"_p_wxSplitterRenderParams", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23327 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}};
23328
23329 static swig_type_info *swig_types_initial[] = {
23330 _swigt__p_wxPostScriptDC,
23331 _swigt__p_wxBrush,
23332 _swigt__p_wxColour,
23333 _swigt__p_wxDC,
23334 _swigt__p_wxMirrorDC,
23335 _swigt__p_form_ops_t,
23336 _swigt__p_wxRendererVersion,
23337 _swigt__p_wxDuplexMode,
23338 _swigt__p_wxPyFontEnumerator,
23339 _swigt__p_char,
23340 _swigt__p_wxIconLocation,
23341 _swigt__p_wxImage,
23342 _swigt__p_wxMetaFileDC,
23343 _swigt__p_wxMask,
23344 _swigt__p_wxSize,
23345 _swigt__p_wxFont,
23346 _swigt__p_wxWindow,
23347 _swigt__p_double,
23348 _swigt__p_wxMemoryDC,
23349 _swigt__p_wxFontMapper,
23350 _swigt__p_wxEffects,
23351 _swigt__p_wxNativeEncodingInfo,
23352 _swigt__p_wxPalette,
23353 _swigt__p_wxBitmap,
23354 _swigt__p_wxObject,
23355 _swigt__p_wxRegionIterator,
23356 _swigt__p_wxRect,
23357 _swigt__p_wxPaperSize,
23358 _swigt__p_wxString,
23359 _swigt__unsigned_int,
23360 _swigt__p_unsigned_int,
23361 _swigt__p_wxPrinterDC,
23362 _swigt__p_wxIconBundle,
23363 _swigt__p_wxPoint,
23364 _swigt__p_wxDash,
23365 _swigt__p_wxScreenDC,
23366 _swigt__p_wxCursor,
23367 _swigt__p_wxClientDC,
23368 _swigt__p_wxBufferedDC,
23369 _swigt__p_wxImageList,
23370 _swigt__p_unsigned_char,
23371 _swigt__p_wxGDIObject,
23372 _swigt__p_wxIcon,
23373 _swigt__p_wxLocale,
23374 _swigt__ptrdiff_t,
23375 _swigt__std__ptrdiff_t,
23376 _swigt__p_wxRegion,
23377 _swigt__p_wxConfigBase,
23378 _swigt__p_wxLanguageInfo,
23379 _swigt__p_wxWindowDC,
23380 _swigt__p_wxPrintData,
23381 _swigt__p_wxBrushList,
23382 _swigt__p_wxFontList,
23383 _swigt__p_wxPen,
23384 _swigt__p_wxBufferedPaintDC,
23385 _swigt__p_wxPaintDC,
23386 _swigt__p_wxPenList,
23387 _swigt__p_int,
23388 _swigt__p_wxMetaFile,
23389 _swigt__p_wxRendererNative,
23390 _swigt__p_unsigned_long,
23391 _swigt__p_wxNativeFontInfo,
23392 _swigt__p_wxEncodingConverter,
23393 _swigt__p_wxSplitterRenderParams,
23394 _swigt__p_wxColourDatabase,
23395 0
23396 };
23397
23398
23399 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
23400
23401 static swig_const_info swig_const_table[] = {
23402 {0, 0, 0, 0.0, 0, 0}};
23403
23404 #ifdef __cplusplus
23405 }
23406 #endif
23407
23408
23409 #ifdef __cplusplus
23410 extern "C" {
23411 #endif
23412
23413 /* Python-specific SWIG API */
23414 #define SWIG_newvarlink() SWIG_Python_newvarlink()
23415 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
23416 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
23417
23418 /* -----------------------------------------------------------------------------
23419 * global variable support code.
23420 * ----------------------------------------------------------------------------- */
23421
23422 typedef struct swig_globalvar {
23423 char *name; /* Name of global variable */
23424 PyObject *(*get_attr)(); /* Return the current value */
23425 int (*set_attr)(PyObject *); /* Set the value */
23426 struct swig_globalvar *next;
23427 } swig_globalvar;
23428
23429 typedef struct swig_varlinkobject {
23430 PyObject_HEAD
23431 swig_globalvar *vars;
23432 } swig_varlinkobject;
23433
23434 static PyObject *
23435 swig_varlink_repr(swig_varlinkobject *v) {
23436 v = v;
23437 return PyString_FromString("<Swig global variables>");
23438 }
23439
23440 static int
23441 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
23442 swig_globalvar *var;
23443 flags = flags;
23444 fprintf(fp,"Swig global variables { ");
23445 for (var = v->vars; var; var=var->next) {
23446 fprintf(fp,"%s", var->name);
23447 if (var->next) fprintf(fp,", ");
23448 }
23449 fprintf(fp," }\n");
23450 return 0;
23451 }
23452
23453 static PyObject *
23454 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
23455 swig_globalvar *var = v->vars;
23456 while (var) {
23457 if (strcmp(var->name,n) == 0) {
23458 return (*var->get_attr)();
23459 }
23460 var = var->next;
23461 }
23462 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
23463 return NULL;
23464 }
23465
23466 static int
23467 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
23468 swig_globalvar *var = v->vars;
23469 while (var) {
23470 if (strcmp(var->name,n) == 0) {
23471 return (*var->set_attr)(p);
23472 }
23473 var = var->next;
23474 }
23475 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
23476 return 1;
23477 }
23478
23479 static PyTypeObject varlinktype = {
23480 PyObject_HEAD_INIT(0)
23481 0, /* Number of items in variable part (ob_size) */
23482 (char *)"swigvarlink", /* Type name (tp_name) */
23483 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
23484 0, /* Itemsize (tp_itemsize) */
23485 0, /* Deallocator (tp_dealloc) */
23486 (printfunc) swig_varlink_print, /* Print (tp_print) */
23487 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
23488 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
23489 0, /* tp_compare */
23490 (reprfunc) swig_varlink_repr, /* tp_repr */
23491 0, /* tp_as_number */
23492 0, /* tp_as_sequence */
23493 0, /* tp_as_mapping */
23494 0, /* tp_hash */
23495 0, /* tp_call */
23496 0, /* tp_str */
23497 0, /* tp_getattro */
23498 0, /* tp_setattro */
23499 0, /* tp_as_buffer */
23500 0, /* tp_flags */
23501 0, /* tp_doc */
23502 #if PY_VERSION_HEX >= 0x02000000
23503 0, /* tp_traverse */
23504 0, /* tp_clear */
23505 #endif
23506 #if PY_VERSION_HEX >= 0x02010000
23507 0, /* tp_richcompare */
23508 0, /* tp_weaklistoffset */
23509 #endif
23510 #if PY_VERSION_HEX >= 0x02020000
23511 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
23512 #endif
23513 #if PY_VERSION_HEX >= 0x02030000
23514 0, /* tp_del */
23515 #endif
23516 #ifdef COUNT_ALLOCS
23517 0,0,0,0 /* tp_alloc -> tp_next */
23518 #endif
23519 };
23520
23521 /* Create a variable linking object for use later */
23522 static PyObject *
23523 SWIG_Python_newvarlink(void) {
23524 swig_varlinkobject *result = 0;
23525 result = PyMem_NEW(swig_varlinkobject,1);
23526 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
23527 result->ob_type = &varlinktype;
23528 result->vars = 0;
23529 result->ob_refcnt = 0;
23530 Py_XINCREF((PyObject *) result);
23531 return ((PyObject*) result);
23532 }
23533
23534 static void
23535 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
23536 swig_varlinkobject *v;
23537 swig_globalvar *gv;
23538 v= (swig_varlinkobject *) p;
23539 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
23540 gv->name = (char *) malloc(strlen(name)+1);
23541 strcpy(gv->name,name);
23542 gv->get_attr = get_attr;
23543 gv->set_attr = set_attr;
23544 gv->next = v->vars;
23545 v->vars = gv;
23546 }
23547
23548 /* -----------------------------------------------------------------------------
23549 * constants/methods manipulation
23550 * ----------------------------------------------------------------------------- */
23551
23552 /* Install Constants */
23553 static void
23554 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
23555 PyObject *obj = 0;
23556 size_t i;
23557 for (i = 0; constants[i].type; i++) {
23558 switch(constants[i].type) {
23559 case SWIG_PY_INT:
23560 obj = PyInt_FromLong(constants[i].lvalue);
23561 break;
23562 case SWIG_PY_FLOAT:
23563 obj = PyFloat_FromDouble(constants[i].dvalue);
23564 break;
23565 case SWIG_PY_STRING:
23566 if (constants[i].pvalue) {
23567 obj = PyString_FromString((char *) constants[i].pvalue);
23568 } else {
23569 Py_INCREF(Py_None);
23570 obj = Py_None;
23571 }
23572 break;
23573 case SWIG_PY_POINTER:
23574 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
23575 break;
23576 case SWIG_PY_BINARY:
23577 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
23578 break;
23579 default:
23580 obj = 0;
23581 break;
23582 }
23583 if (obj) {
23584 PyDict_SetItemString(d,constants[i].name,obj);
23585 Py_DECREF(obj);
23586 }
23587 }
23588 }
23589
23590 /* -----------------------------------------------------------------------------*/
23591 /* Fix SwigMethods to carry the callback ptrs when needed */
23592 /* -----------------------------------------------------------------------------*/
23593
23594 static void
23595 SWIG_Python_FixMethods(PyMethodDef *methods,
23596 swig_const_info *const_table,
23597 swig_type_info **types,
23598 swig_type_info **types_initial) {
23599 size_t i;
23600 for (i = 0; methods[i].ml_name; ++i) {
23601 char *c = methods[i].ml_doc;
23602 if (c && (c = strstr(c, "swig_ptr: "))) {
23603 int j;
23604 swig_const_info *ci = 0;
23605 char *name = c + 10;
23606 for (j = 0; const_table[j].type; j++) {
23607 if (strncmp(const_table[j].name, name,
23608 strlen(const_table[j].name)) == 0) {
23609 ci = &(const_table[j]);
23610 break;
23611 }
23612 }
23613 if (ci) {
23614 size_t shift = (ci->ptype) - types;
23615 swig_type_info *ty = types_initial[shift];
23616 size_t ldoc = (c - methods[i].ml_doc);
23617 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
23618 char *ndoc = (char*)malloc(ldoc + lptr + 10);
23619 char *buff = ndoc;
23620 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
23621 strncpy(buff, methods[i].ml_doc, ldoc);
23622 buff += ldoc;
23623 strncpy(buff, "swig_ptr: ", 10);
23624 buff += 10;
23625 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
23626 methods[i].ml_doc = ndoc;
23627 }
23628 }
23629 }
23630 }
23631
23632 /* -----------------------------------------------------------------------------*
23633 * Initialize type list
23634 * -----------------------------------------------------------------------------*/
23635
23636 #if PY_MAJOR_VERSION < 2
23637 /* PyModule_AddObject function was introduced in Python 2.0. The following function
23638 is copied out of Python/modsupport.c in python version 2.3.4 */
23639 static int
23640 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
23641 {
23642 PyObject *dict;
23643 if (!PyModule_Check(m)) {
23644 PyErr_SetString(PyExc_TypeError,
23645 "PyModule_AddObject() needs module as first arg");
23646 return -1;
23647 }
23648 if (!o) {
23649 PyErr_SetString(PyExc_TypeError,
23650 "PyModule_AddObject() needs non-NULL value");
23651 return -1;
23652 }
23653
23654 dict = PyModule_GetDict(m);
23655 if (dict == NULL) {
23656 /* Internal error -- modules must have a dict! */
23657 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
23658 PyModule_GetName(m));
23659 return -1;
23660 }
23661 if (PyDict_SetItemString(dict, name, o))
23662 return -1;
23663 Py_DECREF(o);
23664 return 0;
23665 }
23666 #endif
23667
23668 static swig_type_info **
23669 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
23670 static PyMethodDef swig_empty_runtime_method_table[] = {
23671 {
23672 NULL, NULL, 0, NULL
23673 }
23674 };/* Sentinel */
23675
23676 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
23677 swig_empty_runtime_method_table);
23678 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
23679 if (pointer && module) {
23680 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
23681 }
23682 return type_list_handle;
23683 }
23684
23685 static swig_type_info **
23686 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
23687 swig_type_info **type_pointer;
23688
23689 /* first check if module already created */
23690 type_pointer = SWIG_Python_GetTypeListHandle();
23691 if (type_pointer) {
23692 return type_pointer;
23693 } else {
23694 /* create a new module and variable */
23695 return SWIG_Python_SetTypeListHandle(type_list_handle);
23696 }
23697 }
23698
23699 #ifdef __cplusplus
23700 }
23701 #endif
23702
23703 /* -----------------------------------------------------------------------------*
23704 * Partial Init method
23705 * -----------------------------------------------------------------------------*/
23706
23707 #ifdef SWIG_LINK_RUNTIME
23708 #ifdef __cplusplus
23709 extern "C"
23710 #endif
23711 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
23712 #endif
23713
23714 #ifdef __cplusplus
23715 extern "C"
23716 #endif
23717 SWIGEXPORT(void) SWIG_init(void) {
23718 static PyObject *SWIG_globals = 0;
23719 static int typeinit = 0;
23720 PyObject *m, *d;
23721 int i;
23722 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
23723
23724 /* Fix SwigMethods to carry the callback ptrs when needed */
23725 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
23726
23727 m = Py_InitModule((char *) SWIG_name, SwigMethods);
23728 d = PyModule_GetDict(m);
23729
23730 if (!typeinit) {
23731 #ifdef SWIG_LINK_RUNTIME
23732 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
23733 #else
23734 # ifndef SWIG_STATIC_RUNTIME
23735 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
23736 # endif
23737 #endif
23738 for (i = 0; swig_types_initial[i]; i++) {
23739 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
23740 }
23741 typeinit = 1;
23742 }
23743 SWIG_InstallConstants(d,swig_const_table);
23744
23745 {
23746 PyDict_SetItemString(d,"OutRegion", SWIG_From_int((int)(wxOutRegion)));
23747 }
23748 {
23749 PyDict_SetItemString(d,"PartRegion", SWIG_From_int((int)(wxPartRegion)));
23750 }
23751 {
23752 PyDict_SetItemString(d,"InRegion", SWIG_From_int((int)(wxInRegion)));
23753 }
23754 {
23755 PyDict_SetItemString(d,"FONTFAMILY_DEFAULT", SWIG_From_int((int)(wxFONTFAMILY_DEFAULT)));
23756 }
23757 {
23758 PyDict_SetItemString(d,"FONTFAMILY_DECORATIVE", SWIG_From_int((int)(wxFONTFAMILY_DECORATIVE)));
23759 }
23760 {
23761 PyDict_SetItemString(d,"FONTFAMILY_ROMAN", SWIG_From_int((int)(wxFONTFAMILY_ROMAN)));
23762 }
23763 {
23764 PyDict_SetItemString(d,"FONTFAMILY_SCRIPT", SWIG_From_int((int)(wxFONTFAMILY_SCRIPT)));
23765 }
23766 {
23767 PyDict_SetItemString(d,"FONTFAMILY_SWISS", SWIG_From_int((int)(wxFONTFAMILY_SWISS)));
23768 }
23769 {
23770 PyDict_SetItemString(d,"FONTFAMILY_MODERN", SWIG_From_int((int)(wxFONTFAMILY_MODERN)));
23771 }
23772 {
23773 PyDict_SetItemString(d,"FONTFAMILY_TELETYPE", SWIG_From_int((int)(wxFONTFAMILY_TELETYPE)));
23774 }
23775 {
23776 PyDict_SetItemString(d,"FONTFAMILY_MAX", SWIG_From_int((int)(wxFONTFAMILY_MAX)));
23777 }
23778 {
23779 PyDict_SetItemString(d,"FONTFAMILY_UNKNOWN", SWIG_From_int((int)(wxFONTFAMILY_UNKNOWN)));
23780 }
23781 {
23782 PyDict_SetItemString(d,"FONTSTYLE_NORMAL", SWIG_From_int((int)(wxFONTSTYLE_NORMAL)));
23783 }
23784 {
23785 PyDict_SetItemString(d,"FONTSTYLE_ITALIC", SWIG_From_int((int)(wxFONTSTYLE_ITALIC)));
23786 }
23787 {
23788 PyDict_SetItemString(d,"FONTSTYLE_SLANT", SWIG_From_int((int)(wxFONTSTYLE_SLANT)));
23789 }
23790 {
23791 PyDict_SetItemString(d,"FONTSTYLE_MAX", SWIG_From_int((int)(wxFONTSTYLE_MAX)));
23792 }
23793 {
23794 PyDict_SetItemString(d,"FONTWEIGHT_NORMAL", SWIG_From_int((int)(wxFONTWEIGHT_NORMAL)));
23795 }
23796 {
23797 PyDict_SetItemString(d,"FONTWEIGHT_LIGHT", SWIG_From_int((int)(wxFONTWEIGHT_LIGHT)));
23798 }
23799 {
23800 PyDict_SetItemString(d,"FONTWEIGHT_BOLD", SWIG_From_int((int)(wxFONTWEIGHT_BOLD)));
23801 }
23802 {
23803 PyDict_SetItemString(d,"FONTWEIGHT_MAX", SWIG_From_int((int)(wxFONTWEIGHT_MAX)));
23804 }
23805 {
23806 PyDict_SetItemString(d,"FONTFLAG_DEFAULT", SWIG_From_int((int)(wxFONTFLAG_DEFAULT)));
23807 }
23808 {
23809 PyDict_SetItemString(d,"FONTFLAG_ITALIC", SWIG_From_int((int)(wxFONTFLAG_ITALIC)));
23810 }
23811 {
23812 PyDict_SetItemString(d,"FONTFLAG_SLANT", SWIG_From_int((int)(wxFONTFLAG_SLANT)));
23813 }
23814 {
23815 PyDict_SetItemString(d,"FONTFLAG_LIGHT", SWIG_From_int((int)(wxFONTFLAG_LIGHT)));
23816 }
23817 {
23818 PyDict_SetItemString(d,"FONTFLAG_BOLD", SWIG_From_int((int)(wxFONTFLAG_BOLD)));
23819 }
23820 {
23821 PyDict_SetItemString(d,"FONTFLAG_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_ANTIALIASED)));
23822 }
23823 {
23824 PyDict_SetItemString(d,"FONTFLAG_NOT_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_NOT_ANTIALIASED)));
23825 }
23826 {
23827 PyDict_SetItemString(d,"FONTFLAG_UNDERLINED", SWIG_From_int((int)(wxFONTFLAG_UNDERLINED)));
23828 }
23829 {
23830 PyDict_SetItemString(d,"FONTFLAG_STRIKETHROUGH", SWIG_From_int((int)(wxFONTFLAG_STRIKETHROUGH)));
23831 }
23832 {
23833 PyDict_SetItemString(d,"FONTFLAG_MASK", SWIG_From_int((int)(wxFONTFLAG_MASK)));
23834 }
23835 {
23836 PyDict_SetItemString(d,"FONTENCODING_SYSTEM", SWIG_From_int((int)(wxFONTENCODING_SYSTEM)));
23837 }
23838 {
23839 PyDict_SetItemString(d,"FONTENCODING_DEFAULT", SWIG_From_int((int)(wxFONTENCODING_DEFAULT)));
23840 }
23841 {
23842 PyDict_SetItemString(d,"FONTENCODING_ISO8859_1", SWIG_From_int((int)(wxFONTENCODING_ISO8859_1)));
23843 }
23844 {
23845 PyDict_SetItemString(d,"FONTENCODING_ISO8859_2", SWIG_From_int((int)(wxFONTENCODING_ISO8859_2)));
23846 }
23847 {
23848 PyDict_SetItemString(d,"FONTENCODING_ISO8859_3", SWIG_From_int((int)(wxFONTENCODING_ISO8859_3)));
23849 }
23850 {
23851 PyDict_SetItemString(d,"FONTENCODING_ISO8859_4", SWIG_From_int((int)(wxFONTENCODING_ISO8859_4)));
23852 }
23853 {
23854 PyDict_SetItemString(d,"FONTENCODING_ISO8859_5", SWIG_From_int((int)(wxFONTENCODING_ISO8859_5)));
23855 }
23856 {
23857 PyDict_SetItemString(d,"FONTENCODING_ISO8859_6", SWIG_From_int((int)(wxFONTENCODING_ISO8859_6)));
23858 }
23859 {
23860 PyDict_SetItemString(d,"FONTENCODING_ISO8859_7", SWIG_From_int((int)(wxFONTENCODING_ISO8859_7)));
23861 }
23862 {
23863 PyDict_SetItemString(d,"FONTENCODING_ISO8859_8", SWIG_From_int((int)(wxFONTENCODING_ISO8859_8)));
23864 }
23865 {
23866 PyDict_SetItemString(d,"FONTENCODING_ISO8859_9", SWIG_From_int((int)(wxFONTENCODING_ISO8859_9)));
23867 }
23868 {
23869 PyDict_SetItemString(d,"FONTENCODING_ISO8859_10", SWIG_From_int((int)(wxFONTENCODING_ISO8859_10)));
23870 }
23871 {
23872 PyDict_SetItemString(d,"FONTENCODING_ISO8859_11", SWIG_From_int((int)(wxFONTENCODING_ISO8859_11)));
23873 }
23874 {
23875 PyDict_SetItemString(d,"FONTENCODING_ISO8859_12", SWIG_From_int((int)(wxFONTENCODING_ISO8859_12)));
23876 }
23877 {
23878 PyDict_SetItemString(d,"FONTENCODING_ISO8859_13", SWIG_From_int((int)(wxFONTENCODING_ISO8859_13)));
23879 }
23880 {
23881 PyDict_SetItemString(d,"FONTENCODING_ISO8859_14", SWIG_From_int((int)(wxFONTENCODING_ISO8859_14)));
23882 }
23883 {
23884 PyDict_SetItemString(d,"FONTENCODING_ISO8859_15", SWIG_From_int((int)(wxFONTENCODING_ISO8859_15)));
23885 }
23886 {
23887 PyDict_SetItemString(d,"FONTENCODING_ISO8859_MAX", SWIG_From_int((int)(wxFONTENCODING_ISO8859_MAX)));
23888 }
23889 {
23890 PyDict_SetItemString(d,"FONTENCODING_KOI8", SWIG_From_int((int)(wxFONTENCODING_KOI8)));
23891 }
23892 {
23893 PyDict_SetItemString(d,"FONTENCODING_KOI8_U", SWIG_From_int((int)(wxFONTENCODING_KOI8_U)));
23894 }
23895 {
23896 PyDict_SetItemString(d,"FONTENCODING_ALTERNATIVE", SWIG_From_int((int)(wxFONTENCODING_ALTERNATIVE)));
23897 }
23898 {
23899 PyDict_SetItemString(d,"FONTENCODING_BULGARIAN", SWIG_From_int((int)(wxFONTENCODING_BULGARIAN)));
23900 }
23901 {
23902 PyDict_SetItemString(d,"FONTENCODING_CP437", SWIG_From_int((int)(wxFONTENCODING_CP437)));
23903 }
23904 {
23905 PyDict_SetItemString(d,"FONTENCODING_CP850", SWIG_From_int((int)(wxFONTENCODING_CP850)));
23906 }
23907 {
23908 PyDict_SetItemString(d,"FONTENCODING_CP852", SWIG_From_int((int)(wxFONTENCODING_CP852)));
23909 }
23910 {
23911 PyDict_SetItemString(d,"FONTENCODING_CP855", SWIG_From_int((int)(wxFONTENCODING_CP855)));
23912 }
23913 {
23914 PyDict_SetItemString(d,"FONTENCODING_CP866", SWIG_From_int((int)(wxFONTENCODING_CP866)));
23915 }
23916 {
23917 PyDict_SetItemString(d,"FONTENCODING_CP874", SWIG_From_int((int)(wxFONTENCODING_CP874)));
23918 }
23919 {
23920 PyDict_SetItemString(d,"FONTENCODING_CP932", SWIG_From_int((int)(wxFONTENCODING_CP932)));
23921 }
23922 {
23923 PyDict_SetItemString(d,"FONTENCODING_CP936", SWIG_From_int((int)(wxFONTENCODING_CP936)));
23924 }
23925 {
23926 PyDict_SetItemString(d,"FONTENCODING_CP949", SWIG_From_int((int)(wxFONTENCODING_CP949)));
23927 }
23928 {
23929 PyDict_SetItemString(d,"FONTENCODING_CP950", SWIG_From_int((int)(wxFONTENCODING_CP950)));
23930 }
23931 {
23932 PyDict_SetItemString(d,"FONTENCODING_CP1250", SWIG_From_int((int)(wxFONTENCODING_CP1250)));
23933 }
23934 {
23935 PyDict_SetItemString(d,"FONTENCODING_CP1251", SWIG_From_int((int)(wxFONTENCODING_CP1251)));
23936 }
23937 {
23938 PyDict_SetItemString(d,"FONTENCODING_CP1252", SWIG_From_int((int)(wxFONTENCODING_CP1252)));
23939 }
23940 {
23941 PyDict_SetItemString(d,"FONTENCODING_CP1253", SWIG_From_int((int)(wxFONTENCODING_CP1253)));
23942 }
23943 {
23944 PyDict_SetItemString(d,"FONTENCODING_CP1254", SWIG_From_int((int)(wxFONTENCODING_CP1254)));
23945 }
23946 {
23947 PyDict_SetItemString(d,"FONTENCODING_CP1255", SWIG_From_int((int)(wxFONTENCODING_CP1255)));
23948 }
23949 {
23950 PyDict_SetItemString(d,"FONTENCODING_CP1256", SWIG_From_int((int)(wxFONTENCODING_CP1256)));
23951 }
23952 {
23953 PyDict_SetItemString(d,"FONTENCODING_CP1257", SWIG_From_int((int)(wxFONTENCODING_CP1257)));
23954 }
23955 {
23956 PyDict_SetItemString(d,"FONTENCODING_CP12_MAX", SWIG_From_int((int)(wxFONTENCODING_CP12_MAX)));
23957 }
23958 {
23959 PyDict_SetItemString(d,"FONTENCODING_UTF7", SWIG_From_int((int)(wxFONTENCODING_UTF7)));
23960 }
23961 {
23962 PyDict_SetItemString(d,"FONTENCODING_UTF8", SWIG_From_int((int)(wxFONTENCODING_UTF8)));
23963 }
23964 {
23965 PyDict_SetItemString(d,"FONTENCODING_EUC_JP", SWIG_From_int((int)(wxFONTENCODING_EUC_JP)));
23966 }
23967 {
23968 PyDict_SetItemString(d,"FONTENCODING_UTF16BE", SWIG_From_int((int)(wxFONTENCODING_UTF16BE)));
23969 }
23970 {
23971 PyDict_SetItemString(d,"FONTENCODING_UTF16LE", SWIG_From_int((int)(wxFONTENCODING_UTF16LE)));
23972 }
23973 {
23974 PyDict_SetItemString(d,"FONTENCODING_UTF32BE", SWIG_From_int((int)(wxFONTENCODING_UTF32BE)));
23975 }
23976 {
23977 PyDict_SetItemString(d,"FONTENCODING_UTF32LE", SWIG_From_int((int)(wxFONTENCODING_UTF32LE)));
23978 }
23979 {
23980 PyDict_SetItemString(d,"FONTENCODING_MACROMAN", SWIG_From_int((int)(wxFONTENCODING_MACROMAN)));
23981 }
23982 {
23983 PyDict_SetItemString(d,"FONTENCODING_MACJAPANESE", SWIG_From_int((int)(wxFONTENCODING_MACJAPANESE)));
23984 }
23985 {
23986 PyDict_SetItemString(d,"FONTENCODING_MACCHINESETRAD", SWIG_From_int((int)(wxFONTENCODING_MACCHINESETRAD)));
23987 }
23988 {
23989 PyDict_SetItemString(d,"FONTENCODING_MACKOREAN", SWIG_From_int((int)(wxFONTENCODING_MACKOREAN)));
23990 }
23991 {
23992 PyDict_SetItemString(d,"FONTENCODING_MACARABIC", SWIG_From_int((int)(wxFONTENCODING_MACARABIC)));
23993 }
23994 {
23995 PyDict_SetItemString(d,"FONTENCODING_MACHEBREW", SWIG_From_int((int)(wxFONTENCODING_MACHEBREW)));
23996 }
23997 {
23998 PyDict_SetItemString(d,"FONTENCODING_MACGREEK", SWIG_From_int((int)(wxFONTENCODING_MACGREEK)));
23999 }
24000 {
24001 PyDict_SetItemString(d,"FONTENCODING_MACCYRILLIC", SWIG_From_int((int)(wxFONTENCODING_MACCYRILLIC)));
24002 }
24003 {
24004 PyDict_SetItemString(d,"FONTENCODING_MACDEVANAGARI", SWIG_From_int((int)(wxFONTENCODING_MACDEVANAGARI)));
24005 }
24006 {
24007 PyDict_SetItemString(d,"FONTENCODING_MACGURMUKHI", SWIG_From_int((int)(wxFONTENCODING_MACGURMUKHI)));
24008 }
24009 {
24010 PyDict_SetItemString(d,"FONTENCODING_MACGUJARATI", SWIG_From_int((int)(wxFONTENCODING_MACGUJARATI)));
24011 }
24012 {
24013 PyDict_SetItemString(d,"FONTENCODING_MACORIYA", SWIG_From_int((int)(wxFONTENCODING_MACORIYA)));
24014 }
24015 {
24016 PyDict_SetItemString(d,"FONTENCODING_MACBENGALI", SWIG_From_int((int)(wxFONTENCODING_MACBENGALI)));
24017 }
24018 {
24019 PyDict_SetItemString(d,"FONTENCODING_MACTAMIL", SWIG_From_int((int)(wxFONTENCODING_MACTAMIL)));
24020 }
24021 {
24022 PyDict_SetItemString(d,"FONTENCODING_MACTELUGU", SWIG_From_int((int)(wxFONTENCODING_MACTELUGU)));
24023 }
24024 {
24025 PyDict_SetItemString(d,"FONTENCODING_MACKANNADA", SWIG_From_int((int)(wxFONTENCODING_MACKANNADA)));
24026 }
24027 {
24028 PyDict_SetItemString(d,"FONTENCODING_MACMALAJALAM", SWIG_From_int((int)(wxFONTENCODING_MACMALAJALAM)));
24029 }
24030 {
24031 PyDict_SetItemString(d,"FONTENCODING_MACSINHALESE", SWIG_From_int((int)(wxFONTENCODING_MACSINHALESE)));
24032 }
24033 {
24034 PyDict_SetItemString(d,"FONTENCODING_MACBURMESE", SWIG_From_int((int)(wxFONTENCODING_MACBURMESE)));
24035 }
24036 {
24037 PyDict_SetItemString(d,"FONTENCODING_MACKHMER", SWIG_From_int((int)(wxFONTENCODING_MACKHMER)));
24038 }
24039 {
24040 PyDict_SetItemString(d,"FONTENCODING_MACTHAI", SWIG_From_int((int)(wxFONTENCODING_MACTHAI)));
24041 }
24042 {
24043 PyDict_SetItemString(d,"FONTENCODING_MACLAOTIAN", SWIG_From_int((int)(wxFONTENCODING_MACLAOTIAN)));
24044 }
24045 {
24046 PyDict_SetItemString(d,"FONTENCODING_MACGEORGIAN", SWIG_From_int((int)(wxFONTENCODING_MACGEORGIAN)));
24047 }
24048 {
24049 PyDict_SetItemString(d,"FONTENCODING_MACARMENIAN", SWIG_From_int((int)(wxFONTENCODING_MACARMENIAN)));
24050 }
24051 {
24052 PyDict_SetItemString(d,"FONTENCODING_MACCHINESESIMP", SWIG_From_int((int)(wxFONTENCODING_MACCHINESESIMP)));
24053 }
24054 {
24055 PyDict_SetItemString(d,"FONTENCODING_MACTIBETAN", SWIG_From_int((int)(wxFONTENCODING_MACTIBETAN)));
24056 }
24057 {
24058 PyDict_SetItemString(d,"FONTENCODING_MACMONGOLIAN", SWIG_From_int((int)(wxFONTENCODING_MACMONGOLIAN)));
24059 }
24060 {
24061 PyDict_SetItemString(d,"FONTENCODING_MACETHIOPIC", SWIG_From_int((int)(wxFONTENCODING_MACETHIOPIC)));
24062 }
24063 {
24064 PyDict_SetItemString(d,"FONTENCODING_MACCENTRALEUR", SWIG_From_int((int)(wxFONTENCODING_MACCENTRALEUR)));
24065 }
24066 {
24067 PyDict_SetItemString(d,"FONTENCODING_MACVIATNAMESE", SWIG_From_int((int)(wxFONTENCODING_MACVIATNAMESE)));
24068 }
24069 {
24070 PyDict_SetItemString(d,"FONTENCODING_MACARABICEXT", SWIG_From_int((int)(wxFONTENCODING_MACARABICEXT)));
24071 }
24072 {
24073 PyDict_SetItemString(d,"FONTENCODING_MACSYMBOL", SWIG_From_int((int)(wxFONTENCODING_MACSYMBOL)));
24074 }
24075 {
24076 PyDict_SetItemString(d,"FONTENCODING_MACDINGBATS", SWIG_From_int((int)(wxFONTENCODING_MACDINGBATS)));
24077 }
24078 {
24079 PyDict_SetItemString(d,"FONTENCODING_MACTURKISH", SWIG_From_int((int)(wxFONTENCODING_MACTURKISH)));
24080 }
24081 {
24082 PyDict_SetItemString(d,"FONTENCODING_MACCROATIAN", SWIG_From_int((int)(wxFONTENCODING_MACCROATIAN)));
24083 }
24084 {
24085 PyDict_SetItemString(d,"FONTENCODING_MACICELANDIC", SWIG_From_int((int)(wxFONTENCODING_MACICELANDIC)));
24086 }
24087 {
24088 PyDict_SetItemString(d,"FONTENCODING_MACROMANIAN", SWIG_From_int((int)(wxFONTENCODING_MACROMANIAN)));
24089 }
24090 {
24091 PyDict_SetItemString(d,"FONTENCODING_MACCELTIC", SWIG_From_int((int)(wxFONTENCODING_MACCELTIC)));
24092 }
24093 {
24094 PyDict_SetItemString(d,"FONTENCODING_MACGAELIC", SWIG_From_int((int)(wxFONTENCODING_MACGAELIC)));
24095 }
24096 {
24097 PyDict_SetItemString(d,"FONTENCODING_MACKEYBOARD", SWIG_From_int((int)(wxFONTENCODING_MACKEYBOARD)));
24098 }
24099 {
24100 PyDict_SetItemString(d,"FONTENCODING_MACMIN", SWIG_From_int((int)(wxFONTENCODING_MACMIN)));
24101 }
24102 {
24103 PyDict_SetItemString(d,"FONTENCODING_MACMAX", SWIG_From_int((int)(wxFONTENCODING_MACMAX)));
24104 }
24105 {
24106 PyDict_SetItemString(d,"FONTENCODING_MAX", SWIG_From_int((int)(wxFONTENCODING_MAX)));
24107 }
24108 {
24109 PyDict_SetItemString(d,"FONTENCODING_UTF16", SWIG_From_int((int)(wxFONTENCODING_UTF16)));
24110 }
24111 {
24112 PyDict_SetItemString(d,"FONTENCODING_UTF32", SWIG_From_int((int)(wxFONTENCODING_UTF32)));
24113 }
24114 {
24115 PyDict_SetItemString(d,"FONTENCODING_UNICODE", SWIG_From_int((int)(wxFONTENCODING_UNICODE)));
24116 }
24117 {
24118 PyDict_SetItemString(d,"FONTENCODING_GB2312", SWIG_From_int((int)(wxFONTENCODING_GB2312)));
24119 }
24120 {
24121 PyDict_SetItemString(d,"FONTENCODING_BIG5", SWIG_From_int((int)(wxFONTENCODING_BIG5)));
24122 }
24123 {
24124 PyDict_SetItemString(d,"FONTENCODING_SHIFT_JIS", SWIG_From_int((int)(wxFONTENCODING_SHIFT_JIS)));
24125 }
24126
24127 wxPyPtrTypeMap_Add("wxFontEnumerator", "wxPyFontEnumerator");
24128
24129 {
24130 PyDict_SetItemString(d,"LANGUAGE_DEFAULT", SWIG_From_int((int)(wxLANGUAGE_DEFAULT)));
24131 }
24132 {
24133 PyDict_SetItemString(d,"LANGUAGE_UNKNOWN", SWIG_From_int((int)(wxLANGUAGE_UNKNOWN)));
24134 }
24135 {
24136 PyDict_SetItemString(d,"LANGUAGE_ABKHAZIAN", SWIG_From_int((int)(wxLANGUAGE_ABKHAZIAN)));
24137 }
24138 {
24139 PyDict_SetItemString(d,"LANGUAGE_AFAR", SWIG_From_int((int)(wxLANGUAGE_AFAR)));
24140 }
24141 {
24142 PyDict_SetItemString(d,"LANGUAGE_AFRIKAANS", SWIG_From_int((int)(wxLANGUAGE_AFRIKAANS)));
24143 }
24144 {
24145 PyDict_SetItemString(d,"LANGUAGE_ALBANIAN", SWIG_From_int((int)(wxLANGUAGE_ALBANIAN)));
24146 }
24147 {
24148 PyDict_SetItemString(d,"LANGUAGE_AMHARIC", SWIG_From_int((int)(wxLANGUAGE_AMHARIC)));
24149 }
24150 {
24151 PyDict_SetItemString(d,"LANGUAGE_ARABIC", SWIG_From_int((int)(wxLANGUAGE_ARABIC)));
24152 }
24153 {
24154 PyDict_SetItemString(d,"LANGUAGE_ARABIC_ALGERIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_ALGERIA)));
24155 }
24156 {
24157 PyDict_SetItemString(d,"LANGUAGE_ARABIC_BAHRAIN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_BAHRAIN)));
24158 }
24159 {
24160 PyDict_SetItemString(d,"LANGUAGE_ARABIC_EGYPT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_EGYPT)));
24161 }
24162 {
24163 PyDict_SetItemString(d,"LANGUAGE_ARABIC_IRAQ", SWIG_From_int((int)(wxLANGUAGE_ARABIC_IRAQ)));
24164 }
24165 {
24166 PyDict_SetItemString(d,"LANGUAGE_ARABIC_JORDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_JORDAN)));
24167 }
24168 {
24169 PyDict_SetItemString(d,"LANGUAGE_ARABIC_KUWAIT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_KUWAIT)));
24170 }
24171 {
24172 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LEBANON", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LEBANON)));
24173 }
24174 {
24175 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LIBYA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LIBYA)));
24176 }
24177 {
24178 PyDict_SetItemString(d,"LANGUAGE_ARABIC_MOROCCO", SWIG_From_int((int)(wxLANGUAGE_ARABIC_MOROCCO)));
24179 }
24180 {
24181 PyDict_SetItemString(d,"LANGUAGE_ARABIC_OMAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_OMAN)));
24182 }
24183 {
24184 PyDict_SetItemString(d,"LANGUAGE_ARABIC_QATAR", SWIG_From_int((int)(wxLANGUAGE_ARABIC_QATAR)));
24185 }
24186 {
24187 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SAUDI_ARABIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SAUDI_ARABIA)));
24188 }
24189 {
24190 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SUDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SUDAN)));
24191 }
24192 {
24193 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SYRIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SYRIA)));
24194 }
24195 {
24196 PyDict_SetItemString(d,"LANGUAGE_ARABIC_TUNISIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_TUNISIA)));
24197 }
24198 {
24199 PyDict_SetItemString(d,"LANGUAGE_ARABIC_UAE", SWIG_From_int((int)(wxLANGUAGE_ARABIC_UAE)));
24200 }
24201 {
24202 PyDict_SetItemString(d,"LANGUAGE_ARABIC_YEMEN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_YEMEN)));
24203 }
24204 {
24205 PyDict_SetItemString(d,"LANGUAGE_ARMENIAN", SWIG_From_int((int)(wxLANGUAGE_ARMENIAN)));
24206 }
24207 {
24208 PyDict_SetItemString(d,"LANGUAGE_ASSAMESE", SWIG_From_int((int)(wxLANGUAGE_ASSAMESE)));
24209 }
24210 {
24211 PyDict_SetItemString(d,"LANGUAGE_AYMARA", SWIG_From_int((int)(wxLANGUAGE_AYMARA)));
24212 }
24213 {
24214 PyDict_SetItemString(d,"LANGUAGE_AZERI", SWIG_From_int((int)(wxLANGUAGE_AZERI)));
24215 }
24216 {
24217 PyDict_SetItemString(d,"LANGUAGE_AZERI_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_AZERI_CYRILLIC)));
24218 }
24219 {
24220 PyDict_SetItemString(d,"LANGUAGE_AZERI_LATIN", SWIG_From_int((int)(wxLANGUAGE_AZERI_LATIN)));
24221 }
24222 {
24223 PyDict_SetItemString(d,"LANGUAGE_BASHKIR", SWIG_From_int((int)(wxLANGUAGE_BASHKIR)));
24224 }
24225 {
24226 PyDict_SetItemString(d,"LANGUAGE_BASQUE", SWIG_From_int((int)(wxLANGUAGE_BASQUE)));
24227 }
24228 {
24229 PyDict_SetItemString(d,"LANGUAGE_BELARUSIAN", SWIG_From_int((int)(wxLANGUAGE_BELARUSIAN)));
24230 }
24231 {
24232 PyDict_SetItemString(d,"LANGUAGE_BENGALI", SWIG_From_int((int)(wxLANGUAGE_BENGALI)));
24233 }
24234 {
24235 PyDict_SetItemString(d,"LANGUAGE_BHUTANI", SWIG_From_int((int)(wxLANGUAGE_BHUTANI)));
24236 }
24237 {
24238 PyDict_SetItemString(d,"LANGUAGE_BIHARI", SWIG_From_int((int)(wxLANGUAGE_BIHARI)));
24239 }
24240 {
24241 PyDict_SetItemString(d,"LANGUAGE_BISLAMA", SWIG_From_int((int)(wxLANGUAGE_BISLAMA)));
24242 }
24243 {
24244 PyDict_SetItemString(d,"LANGUAGE_BRETON", SWIG_From_int((int)(wxLANGUAGE_BRETON)));
24245 }
24246 {
24247 PyDict_SetItemString(d,"LANGUAGE_BULGARIAN", SWIG_From_int((int)(wxLANGUAGE_BULGARIAN)));
24248 }
24249 {
24250 PyDict_SetItemString(d,"LANGUAGE_BURMESE", SWIG_From_int((int)(wxLANGUAGE_BURMESE)));
24251 }
24252 {
24253 PyDict_SetItemString(d,"LANGUAGE_CAMBODIAN", SWIG_From_int((int)(wxLANGUAGE_CAMBODIAN)));
24254 }
24255 {
24256 PyDict_SetItemString(d,"LANGUAGE_CATALAN", SWIG_From_int((int)(wxLANGUAGE_CATALAN)));
24257 }
24258 {
24259 PyDict_SetItemString(d,"LANGUAGE_CHINESE", SWIG_From_int((int)(wxLANGUAGE_CHINESE)));
24260 }
24261 {
24262 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SIMPLIFIED", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SIMPLIFIED)));
24263 }
24264 {
24265 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TRADITIONAL", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TRADITIONAL)));
24266 }
24267 {
24268 PyDict_SetItemString(d,"LANGUAGE_CHINESE_HONGKONG", SWIG_From_int((int)(wxLANGUAGE_CHINESE_HONGKONG)));
24269 }
24270 {
24271 PyDict_SetItemString(d,"LANGUAGE_CHINESE_MACAU", SWIG_From_int((int)(wxLANGUAGE_CHINESE_MACAU)));
24272 }
24273 {
24274 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SINGAPORE", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SINGAPORE)));
24275 }
24276 {
24277 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TAIWAN", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TAIWAN)));
24278 }
24279 {
24280 PyDict_SetItemString(d,"LANGUAGE_CORSICAN", SWIG_From_int((int)(wxLANGUAGE_CORSICAN)));
24281 }
24282 {
24283 PyDict_SetItemString(d,"LANGUAGE_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_CROATIAN)));
24284 }
24285 {
24286 PyDict_SetItemString(d,"LANGUAGE_CZECH", SWIG_From_int((int)(wxLANGUAGE_CZECH)));
24287 }
24288 {
24289 PyDict_SetItemString(d,"LANGUAGE_DANISH", SWIG_From_int((int)(wxLANGUAGE_DANISH)));
24290 }
24291 {
24292 PyDict_SetItemString(d,"LANGUAGE_DUTCH", SWIG_From_int((int)(wxLANGUAGE_DUTCH)));
24293 }
24294 {
24295 PyDict_SetItemString(d,"LANGUAGE_DUTCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_DUTCH_BELGIAN)));
24296 }
24297 {
24298 PyDict_SetItemString(d,"LANGUAGE_ENGLISH", SWIG_From_int((int)(wxLANGUAGE_ENGLISH)));
24299 }
24300 {
24301 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_UK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_UK)));
24302 }
24303 {
24304 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_US", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_US)));
24305 }
24306 {
24307 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_AUSTRALIA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_AUSTRALIA)));
24308 }
24309 {
24310 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BELIZE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BELIZE)));
24311 }
24312 {
24313 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BOTSWANA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BOTSWANA)));
24314 }
24315 {
24316 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CANADA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CANADA)));
24317 }
24318 {
24319 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CARIBBEAN", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CARIBBEAN)));
24320 }
24321 {
24322 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_DENMARK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_DENMARK)));
24323 }
24324 {
24325 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_EIRE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_EIRE)));
24326 }
24327 {
24328 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_JAMAICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_JAMAICA)));
24329 }
24330 {
24331 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_NEW_ZEALAND", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_NEW_ZEALAND)));
24332 }
24333 {
24334 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_PHILIPPINES", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_PHILIPPINES)));
24335 }
24336 {
24337 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_SOUTH_AFRICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_SOUTH_AFRICA)));
24338 }
24339 {
24340 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_TRINIDAD", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_TRINIDAD)));
24341 }
24342 {
24343 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_ZIMBABWE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_ZIMBABWE)));
24344 }
24345 {
24346 PyDict_SetItemString(d,"LANGUAGE_ESPERANTO", SWIG_From_int((int)(wxLANGUAGE_ESPERANTO)));
24347 }
24348 {
24349 PyDict_SetItemString(d,"LANGUAGE_ESTONIAN", SWIG_From_int((int)(wxLANGUAGE_ESTONIAN)));
24350 }
24351 {
24352 PyDict_SetItemString(d,"LANGUAGE_FAEROESE", SWIG_From_int((int)(wxLANGUAGE_FAEROESE)));
24353 }
24354 {
24355 PyDict_SetItemString(d,"LANGUAGE_FARSI", SWIG_From_int((int)(wxLANGUAGE_FARSI)));
24356 }
24357 {
24358 PyDict_SetItemString(d,"LANGUAGE_FIJI", SWIG_From_int((int)(wxLANGUAGE_FIJI)));
24359 }
24360 {
24361 PyDict_SetItemString(d,"LANGUAGE_FINNISH", SWIG_From_int((int)(wxLANGUAGE_FINNISH)));
24362 }
24363 {
24364 PyDict_SetItemString(d,"LANGUAGE_FRENCH", SWIG_From_int((int)(wxLANGUAGE_FRENCH)));
24365 }
24366 {
24367 PyDict_SetItemString(d,"LANGUAGE_FRENCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_BELGIAN)));
24368 }
24369 {
24370 PyDict_SetItemString(d,"LANGUAGE_FRENCH_CANADIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_CANADIAN)));
24371 }
24372 {
24373 PyDict_SetItemString(d,"LANGUAGE_FRENCH_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_FRENCH_LUXEMBOURG)));
24374 }
24375 {
24376 PyDict_SetItemString(d,"LANGUAGE_FRENCH_MONACO", SWIG_From_int((int)(wxLANGUAGE_FRENCH_MONACO)));
24377 }
24378 {
24379 PyDict_SetItemString(d,"LANGUAGE_FRENCH_SWISS", SWIG_From_int((int)(wxLANGUAGE_FRENCH_SWISS)));
24380 }
24381 {
24382 PyDict_SetItemString(d,"LANGUAGE_FRISIAN", SWIG_From_int((int)(wxLANGUAGE_FRISIAN)));
24383 }
24384 {
24385 PyDict_SetItemString(d,"LANGUAGE_GALICIAN", SWIG_From_int((int)(wxLANGUAGE_GALICIAN)));
24386 }
24387 {
24388 PyDict_SetItemString(d,"LANGUAGE_GEORGIAN", SWIG_From_int((int)(wxLANGUAGE_GEORGIAN)));
24389 }
24390 {
24391 PyDict_SetItemString(d,"LANGUAGE_GERMAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN)));
24392 }
24393 {
24394 PyDict_SetItemString(d,"LANGUAGE_GERMAN_AUSTRIAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_AUSTRIAN)));
24395 }
24396 {
24397 PyDict_SetItemString(d,"LANGUAGE_GERMAN_BELGIUM", SWIG_From_int((int)(wxLANGUAGE_GERMAN_BELGIUM)));
24398 }
24399 {
24400 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LIECHTENSTEIN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LIECHTENSTEIN)));
24401 }
24402 {
24403 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LUXEMBOURG)));
24404 }
24405 {
24406 PyDict_SetItemString(d,"LANGUAGE_GERMAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_GERMAN_SWISS)));
24407 }
24408 {
24409 PyDict_SetItemString(d,"LANGUAGE_GREEK", SWIG_From_int((int)(wxLANGUAGE_GREEK)));
24410 }
24411 {
24412 PyDict_SetItemString(d,"LANGUAGE_GREENLANDIC", SWIG_From_int((int)(wxLANGUAGE_GREENLANDIC)));
24413 }
24414 {
24415 PyDict_SetItemString(d,"LANGUAGE_GUARANI", SWIG_From_int((int)(wxLANGUAGE_GUARANI)));
24416 }
24417 {
24418 PyDict_SetItemString(d,"LANGUAGE_GUJARATI", SWIG_From_int((int)(wxLANGUAGE_GUJARATI)));
24419 }
24420 {
24421 PyDict_SetItemString(d,"LANGUAGE_HAUSA", SWIG_From_int((int)(wxLANGUAGE_HAUSA)));
24422 }
24423 {
24424 PyDict_SetItemString(d,"LANGUAGE_HEBREW", SWIG_From_int((int)(wxLANGUAGE_HEBREW)));
24425 }
24426 {
24427 PyDict_SetItemString(d,"LANGUAGE_HINDI", SWIG_From_int((int)(wxLANGUAGE_HINDI)));
24428 }
24429 {
24430 PyDict_SetItemString(d,"LANGUAGE_HUNGARIAN", SWIG_From_int((int)(wxLANGUAGE_HUNGARIAN)));
24431 }
24432 {
24433 PyDict_SetItemString(d,"LANGUAGE_ICELANDIC", SWIG_From_int((int)(wxLANGUAGE_ICELANDIC)));
24434 }
24435 {
24436 PyDict_SetItemString(d,"LANGUAGE_INDONESIAN", SWIG_From_int((int)(wxLANGUAGE_INDONESIAN)));
24437 }
24438 {
24439 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUA", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUA)));
24440 }
24441 {
24442 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUE", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUE)));
24443 }
24444 {
24445 PyDict_SetItemString(d,"LANGUAGE_INUKTITUT", SWIG_From_int((int)(wxLANGUAGE_INUKTITUT)));
24446 }
24447 {
24448 PyDict_SetItemString(d,"LANGUAGE_INUPIAK", SWIG_From_int((int)(wxLANGUAGE_INUPIAK)));
24449 }
24450 {
24451 PyDict_SetItemString(d,"LANGUAGE_IRISH", SWIG_From_int((int)(wxLANGUAGE_IRISH)));
24452 }
24453 {
24454 PyDict_SetItemString(d,"LANGUAGE_ITALIAN", SWIG_From_int((int)(wxLANGUAGE_ITALIAN)));
24455 }
24456 {
24457 PyDict_SetItemString(d,"LANGUAGE_ITALIAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_ITALIAN_SWISS)));
24458 }
24459 {
24460 PyDict_SetItemString(d,"LANGUAGE_JAPANESE", SWIG_From_int((int)(wxLANGUAGE_JAPANESE)));
24461 }
24462 {
24463 PyDict_SetItemString(d,"LANGUAGE_JAVANESE", SWIG_From_int((int)(wxLANGUAGE_JAVANESE)));
24464 }
24465 {
24466 PyDict_SetItemString(d,"LANGUAGE_KANNADA", SWIG_From_int((int)(wxLANGUAGE_KANNADA)));
24467 }
24468 {
24469 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI)));
24470 }
24471 {
24472 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI_INDIA", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI_INDIA)));
24473 }
24474 {
24475 PyDict_SetItemString(d,"LANGUAGE_KAZAKH", SWIG_From_int((int)(wxLANGUAGE_KAZAKH)));
24476 }
24477 {
24478 PyDict_SetItemString(d,"LANGUAGE_KERNEWEK", SWIG_From_int((int)(wxLANGUAGE_KERNEWEK)));
24479 }
24480 {
24481 PyDict_SetItemString(d,"LANGUAGE_KINYARWANDA", SWIG_From_int((int)(wxLANGUAGE_KINYARWANDA)));
24482 }
24483 {
24484 PyDict_SetItemString(d,"LANGUAGE_KIRGHIZ", SWIG_From_int((int)(wxLANGUAGE_KIRGHIZ)));
24485 }
24486 {
24487 PyDict_SetItemString(d,"LANGUAGE_KIRUNDI", SWIG_From_int((int)(wxLANGUAGE_KIRUNDI)));
24488 }
24489 {
24490 PyDict_SetItemString(d,"LANGUAGE_KONKANI", SWIG_From_int((int)(wxLANGUAGE_KONKANI)));
24491 }
24492 {
24493 PyDict_SetItemString(d,"LANGUAGE_KOREAN", SWIG_From_int((int)(wxLANGUAGE_KOREAN)));
24494 }
24495 {
24496 PyDict_SetItemString(d,"LANGUAGE_KURDISH", SWIG_From_int((int)(wxLANGUAGE_KURDISH)));
24497 }
24498 {
24499 PyDict_SetItemString(d,"LANGUAGE_LAOTHIAN", SWIG_From_int((int)(wxLANGUAGE_LAOTHIAN)));
24500 }
24501 {
24502 PyDict_SetItemString(d,"LANGUAGE_LATIN", SWIG_From_int((int)(wxLANGUAGE_LATIN)));
24503 }
24504 {
24505 PyDict_SetItemString(d,"LANGUAGE_LATVIAN", SWIG_From_int((int)(wxLANGUAGE_LATVIAN)));
24506 }
24507 {
24508 PyDict_SetItemString(d,"LANGUAGE_LINGALA", SWIG_From_int((int)(wxLANGUAGE_LINGALA)));
24509 }
24510 {
24511 PyDict_SetItemString(d,"LANGUAGE_LITHUANIAN", SWIG_From_int((int)(wxLANGUAGE_LITHUANIAN)));
24512 }
24513 {
24514 PyDict_SetItemString(d,"LANGUAGE_MACEDONIAN", SWIG_From_int((int)(wxLANGUAGE_MACEDONIAN)));
24515 }
24516 {
24517 PyDict_SetItemString(d,"LANGUAGE_MALAGASY", SWIG_From_int((int)(wxLANGUAGE_MALAGASY)));
24518 }
24519 {
24520 PyDict_SetItemString(d,"LANGUAGE_MALAY", SWIG_From_int((int)(wxLANGUAGE_MALAY)));
24521 }
24522 {
24523 PyDict_SetItemString(d,"LANGUAGE_MALAYALAM", SWIG_From_int((int)(wxLANGUAGE_MALAYALAM)));
24524 }
24525 {
24526 PyDict_SetItemString(d,"LANGUAGE_MALAY_BRUNEI_DARUSSALAM", SWIG_From_int((int)(wxLANGUAGE_MALAY_BRUNEI_DARUSSALAM)));
24527 }
24528 {
24529 PyDict_SetItemString(d,"LANGUAGE_MALAY_MALAYSIA", SWIG_From_int((int)(wxLANGUAGE_MALAY_MALAYSIA)));
24530 }
24531 {
24532 PyDict_SetItemString(d,"LANGUAGE_MALTESE", SWIG_From_int((int)(wxLANGUAGE_MALTESE)));
24533 }
24534 {
24535 PyDict_SetItemString(d,"LANGUAGE_MANIPURI", SWIG_From_int((int)(wxLANGUAGE_MANIPURI)));
24536 }
24537 {
24538 PyDict_SetItemString(d,"LANGUAGE_MAORI", SWIG_From_int((int)(wxLANGUAGE_MAORI)));
24539 }
24540 {
24541 PyDict_SetItemString(d,"LANGUAGE_MARATHI", SWIG_From_int((int)(wxLANGUAGE_MARATHI)));
24542 }
24543 {
24544 PyDict_SetItemString(d,"LANGUAGE_MOLDAVIAN", SWIG_From_int((int)(wxLANGUAGE_MOLDAVIAN)));
24545 }
24546 {
24547 PyDict_SetItemString(d,"LANGUAGE_MONGOLIAN", SWIG_From_int((int)(wxLANGUAGE_MONGOLIAN)));
24548 }
24549 {
24550 PyDict_SetItemString(d,"LANGUAGE_NAURU", SWIG_From_int((int)(wxLANGUAGE_NAURU)));
24551 }
24552 {
24553 PyDict_SetItemString(d,"LANGUAGE_NEPALI", SWIG_From_int((int)(wxLANGUAGE_NEPALI)));
24554 }
24555 {
24556 PyDict_SetItemString(d,"LANGUAGE_NEPALI_INDIA", SWIG_From_int((int)(wxLANGUAGE_NEPALI_INDIA)));
24557 }
24558 {
24559 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_BOKMAL", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_BOKMAL)));
24560 }
24561 {
24562 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_NYNORSK", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_NYNORSK)));
24563 }
24564 {
24565 PyDict_SetItemString(d,"LANGUAGE_OCCITAN", SWIG_From_int((int)(wxLANGUAGE_OCCITAN)));
24566 }
24567 {
24568 PyDict_SetItemString(d,"LANGUAGE_ORIYA", SWIG_From_int((int)(wxLANGUAGE_ORIYA)));
24569 }
24570 {
24571 PyDict_SetItemString(d,"LANGUAGE_OROMO", SWIG_From_int((int)(wxLANGUAGE_OROMO)));
24572 }
24573 {
24574 PyDict_SetItemString(d,"LANGUAGE_PASHTO", SWIG_From_int((int)(wxLANGUAGE_PASHTO)));
24575 }
24576 {
24577 PyDict_SetItemString(d,"LANGUAGE_POLISH", SWIG_From_int((int)(wxLANGUAGE_POLISH)));
24578 }
24579 {
24580 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE)));
24581 }
24582 {
24583 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE_BRAZILIAN", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE_BRAZILIAN)));
24584 }
24585 {
24586 PyDict_SetItemString(d,"LANGUAGE_PUNJABI", SWIG_From_int((int)(wxLANGUAGE_PUNJABI)));
24587 }
24588 {
24589 PyDict_SetItemString(d,"LANGUAGE_QUECHUA", SWIG_From_int((int)(wxLANGUAGE_QUECHUA)));
24590 }
24591 {
24592 PyDict_SetItemString(d,"LANGUAGE_RHAETO_ROMANCE", SWIG_From_int((int)(wxLANGUAGE_RHAETO_ROMANCE)));
24593 }
24594 {
24595 PyDict_SetItemString(d,"LANGUAGE_ROMANIAN", SWIG_From_int((int)(wxLANGUAGE_ROMANIAN)));
24596 }
24597 {
24598 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN)));
24599 }
24600 {
24601 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN_UKRAINE", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN_UKRAINE)));
24602 }
24603 {
24604 PyDict_SetItemString(d,"LANGUAGE_SAMOAN", SWIG_From_int((int)(wxLANGUAGE_SAMOAN)));
24605 }
24606 {
24607 PyDict_SetItemString(d,"LANGUAGE_SANGHO", SWIG_From_int((int)(wxLANGUAGE_SANGHO)));
24608 }
24609 {
24610 PyDict_SetItemString(d,"LANGUAGE_SANSKRIT", SWIG_From_int((int)(wxLANGUAGE_SANSKRIT)));
24611 }
24612 {
24613 PyDict_SetItemString(d,"LANGUAGE_SCOTS_GAELIC", SWIG_From_int((int)(wxLANGUAGE_SCOTS_GAELIC)));
24614 }
24615 {
24616 PyDict_SetItemString(d,"LANGUAGE_SERBIAN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN)));
24617 }
24618 {
24619 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_CYRILLIC)));
24620 }
24621 {
24622 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_LATIN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_LATIN)));
24623 }
24624 {
24625 PyDict_SetItemString(d,"LANGUAGE_SERBO_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_SERBO_CROATIAN)));
24626 }
24627 {
24628 PyDict_SetItemString(d,"LANGUAGE_SESOTHO", SWIG_From_int((int)(wxLANGUAGE_SESOTHO)));
24629 }
24630 {
24631 PyDict_SetItemString(d,"LANGUAGE_SETSWANA", SWIG_From_int((int)(wxLANGUAGE_SETSWANA)));
24632 }
24633 {
24634 PyDict_SetItemString(d,"LANGUAGE_SHONA", SWIG_From_int((int)(wxLANGUAGE_SHONA)));
24635 }
24636 {
24637 PyDict_SetItemString(d,"LANGUAGE_SINDHI", SWIG_From_int((int)(wxLANGUAGE_SINDHI)));
24638 }
24639 {
24640 PyDict_SetItemString(d,"LANGUAGE_SINHALESE", SWIG_From_int((int)(wxLANGUAGE_SINHALESE)));
24641 }
24642 {
24643 PyDict_SetItemString(d,"LANGUAGE_SISWATI", SWIG_From_int((int)(wxLANGUAGE_SISWATI)));
24644 }
24645 {
24646 PyDict_SetItemString(d,"LANGUAGE_SLOVAK", SWIG_From_int((int)(wxLANGUAGE_SLOVAK)));
24647 }
24648 {
24649 PyDict_SetItemString(d,"LANGUAGE_SLOVENIAN", SWIG_From_int((int)(wxLANGUAGE_SLOVENIAN)));
24650 }
24651 {
24652 PyDict_SetItemString(d,"LANGUAGE_SOMALI", SWIG_From_int((int)(wxLANGUAGE_SOMALI)));
24653 }
24654 {
24655 PyDict_SetItemString(d,"LANGUAGE_SPANISH", SWIG_From_int((int)(wxLANGUAGE_SPANISH)));
24656 }
24657 {
24658 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ARGENTINA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ARGENTINA)));
24659 }
24660 {
24661 PyDict_SetItemString(d,"LANGUAGE_SPANISH_BOLIVIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_BOLIVIA)));
24662 }
24663 {
24664 PyDict_SetItemString(d,"LANGUAGE_SPANISH_CHILE", SWIG_From_int((int)(wxLANGUAGE_SPANISH_CHILE)));
24665 }
24666 {
24667 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COLOMBIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COLOMBIA)));
24668 }
24669 {
24670 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COSTA_RICA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COSTA_RICA)));
24671 }
24672 {
24673 PyDict_SetItemString(d,"LANGUAGE_SPANISH_DOMINICAN_REPUBLIC", SWIG_From_int((int)(wxLANGUAGE_SPANISH_DOMINICAN_REPUBLIC)));
24674 }
24675 {
24676 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ECUADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ECUADOR)));
24677 }
24678 {
24679 PyDict_SetItemString(d,"LANGUAGE_SPANISH_EL_SALVADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_EL_SALVADOR)));
24680 }
24681 {
24682 PyDict_SetItemString(d,"LANGUAGE_SPANISH_GUATEMALA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_GUATEMALA)));
24683 }
24684 {
24685 PyDict_SetItemString(d,"LANGUAGE_SPANISH_HONDURAS", SWIG_From_int((int)(wxLANGUAGE_SPANISH_HONDURAS)));
24686 }
24687 {
24688 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MEXICAN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MEXICAN)));
24689 }
24690 {
24691 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MODERN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MODERN)));
24692 }
24693 {
24694 PyDict_SetItemString(d,"LANGUAGE_SPANISH_NICARAGUA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_NICARAGUA)));
24695 }
24696 {
24697 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PANAMA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PANAMA)));
24698 }
24699 {
24700 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PARAGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PARAGUAY)));
24701 }
24702 {
24703 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PERU", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PERU)));
24704 }
24705 {
24706 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PUERTO_RICO", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PUERTO_RICO)));
24707 }
24708 {
24709 PyDict_SetItemString(d,"LANGUAGE_SPANISH_URUGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_URUGUAY)));
24710 }
24711 {
24712 PyDict_SetItemString(d,"LANGUAGE_SPANISH_US", SWIG_From_int((int)(wxLANGUAGE_SPANISH_US)));
24713 }
24714 {
24715 PyDict_SetItemString(d,"LANGUAGE_SPANISH_VENEZUELA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_VENEZUELA)));
24716 }
24717 {
24718 PyDict_SetItemString(d,"LANGUAGE_SUNDANESE", SWIG_From_int((int)(wxLANGUAGE_SUNDANESE)));
24719 }
24720 {
24721 PyDict_SetItemString(d,"LANGUAGE_SWAHILI", SWIG_From_int((int)(wxLANGUAGE_SWAHILI)));
24722 }
24723 {
24724 PyDict_SetItemString(d,"LANGUAGE_SWEDISH", SWIG_From_int((int)(wxLANGUAGE_SWEDISH)));
24725 }
24726 {
24727 PyDict_SetItemString(d,"LANGUAGE_SWEDISH_FINLAND", SWIG_From_int((int)(wxLANGUAGE_SWEDISH_FINLAND)));
24728 }
24729 {
24730 PyDict_SetItemString(d,"LANGUAGE_TAGALOG", SWIG_From_int((int)(wxLANGUAGE_TAGALOG)));
24731 }
24732 {
24733 PyDict_SetItemString(d,"LANGUAGE_TAJIK", SWIG_From_int((int)(wxLANGUAGE_TAJIK)));
24734 }
24735 {
24736 PyDict_SetItemString(d,"LANGUAGE_TAMIL", SWIG_From_int((int)(wxLANGUAGE_TAMIL)));
24737 }
24738 {
24739 PyDict_SetItemString(d,"LANGUAGE_TATAR", SWIG_From_int((int)(wxLANGUAGE_TATAR)));
24740 }
24741 {
24742 PyDict_SetItemString(d,"LANGUAGE_TELUGU", SWIG_From_int((int)(wxLANGUAGE_TELUGU)));
24743 }
24744 {
24745 PyDict_SetItemString(d,"LANGUAGE_THAI", SWIG_From_int((int)(wxLANGUAGE_THAI)));
24746 }
24747 {
24748 PyDict_SetItemString(d,"LANGUAGE_TIBETAN", SWIG_From_int((int)(wxLANGUAGE_TIBETAN)));
24749 }
24750 {
24751 PyDict_SetItemString(d,"LANGUAGE_TIGRINYA", SWIG_From_int((int)(wxLANGUAGE_TIGRINYA)));
24752 }
24753 {
24754 PyDict_SetItemString(d,"LANGUAGE_TONGA", SWIG_From_int((int)(wxLANGUAGE_TONGA)));
24755 }
24756 {
24757 PyDict_SetItemString(d,"LANGUAGE_TSONGA", SWIG_From_int((int)(wxLANGUAGE_TSONGA)));
24758 }
24759 {
24760 PyDict_SetItemString(d,"LANGUAGE_TURKISH", SWIG_From_int((int)(wxLANGUAGE_TURKISH)));
24761 }
24762 {
24763 PyDict_SetItemString(d,"LANGUAGE_TURKMEN", SWIG_From_int((int)(wxLANGUAGE_TURKMEN)));
24764 }
24765 {
24766 PyDict_SetItemString(d,"LANGUAGE_TWI", SWIG_From_int((int)(wxLANGUAGE_TWI)));
24767 }
24768 {
24769 PyDict_SetItemString(d,"LANGUAGE_UIGHUR", SWIG_From_int((int)(wxLANGUAGE_UIGHUR)));
24770 }
24771 {
24772 PyDict_SetItemString(d,"LANGUAGE_UKRAINIAN", SWIG_From_int((int)(wxLANGUAGE_UKRAINIAN)));
24773 }
24774 {
24775 PyDict_SetItemString(d,"LANGUAGE_URDU", SWIG_From_int((int)(wxLANGUAGE_URDU)));
24776 }
24777 {
24778 PyDict_SetItemString(d,"LANGUAGE_URDU_INDIA", SWIG_From_int((int)(wxLANGUAGE_URDU_INDIA)));
24779 }
24780 {
24781 PyDict_SetItemString(d,"LANGUAGE_URDU_PAKISTAN", SWIG_From_int((int)(wxLANGUAGE_URDU_PAKISTAN)));
24782 }
24783 {
24784 PyDict_SetItemString(d,"LANGUAGE_UZBEK", SWIG_From_int((int)(wxLANGUAGE_UZBEK)));
24785 }
24786 {
24787 PyDict_SetItemString(d,"LANGUAGE_UZBEK_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_UZBEK_CYRILLIC)));
24788 }
24789 {
24790 PyDict_SetItemString(d,"LANGUAGE_UZBEK_LATIN", SWIG_From_int((int)(wxLANGUAGE_UZBEK_LATIN)));
24791 }
24792 {
24793 PyDict_SetItemString(d,"LANGUAGE_VIETNAMESE", SWIG_From_int((int)(wxLANGUAGE_VIETNAMESE)));
24794 }
24795 {
24796 PyDict_SetItemString(d,"LANGUAGE_VOLAPUK", SWIG_From_int((int)(wxLANGUAGE_VOLAPUK)));
24797 }
24798 {
24799 PyDict_SetItemString(d,"LANGUAGE_WELSH", SWIG_From_int((int)(wxLANGUAGE_WELSH)));
24800 }
24801 {
24802 PyDict_SetItemString(d,"LANGUAGE_WOLOF", SWIG_From_int((int)(wxLANGUAGE_WOLOF)));
24803 }
24804 {
24805 PyDict_SetItemString(d,"LANGUAGE_XHOSA", SWIG_From_int((int)(wxLANGUAGE_XHOSA)));
24806 }
24807 {
24808 PyDict_SetItemString(d,"LANGUAGE_YIDDISH", SWIG_From_int((int)(wxLANGUAGE_YIDDISH)));
24809 }
24810 {
24811 PyDict_SetItemString(d,"LANGUAGE_YORUBA", SWIG_From_int((int)(wxLANGUAGE_YORUBA)));
24812 }
24813 {
24814 PyDict_SetItemString(d,"LANGUAGE_ZHUANG", SWIG_From_int((int)(wxLANGUAGE_ZHUANG)));
24815 }
24816 {
24817 PyDict_SetItemString(d,"LANGUAGE_ZULU", SWIG_From_int((int)(wxLANGUAGE_ZULU)));
24818 }
24819 {
24820 PyDict_SetItemString(d,"LANGUAGE_USER_DEFINED", SWIG_From_int((int)(wxLANGUAGE_USER_DEFINED)));
24821 }
24822 {
24823 PyDict_SetItemString(d,"LOCALE_CAT_NUMBER", SWIG_From_int((int)(wxLOCALE_CAT_NUMBER)));
24824 }
24825 {
24826 PyDict_SetItemString(d,"LOCALE_CAT_DATE", SWIG_From_int((int)(wxLOCALE_CAT_DATE)));
24827 }
24828 {
24829 PyDict_SetItemString(d,"LOCALE_CAT_MONEY", SWIG_From_int((int)(wxLOCALE_CAT_MONEY)));
24830 }
24831 {
24832 PyDict_SetItemString(d,"LOCALE_CAT_MAX", SWIG_From_int((int)(wxLOCALE_CAT_MAX)));
24833 }
24834 {
24835 PyDict_SetItemString(d,"LOCALE_THOUSANDS_SEP", SWIG_From_int((int)(wxLOCALE_THOUSANDS_SEP)));
24836 }
24837 {
24838 PyDict_SetItemString(d,"LOCALE_DECIMAL_POINT", SWIG_From_int((int)(wxLOCALE_DECIMAL_POINT)));
24839 }
24840 {
24841 PyDict_SetItemString(d,"LOCALE_LOAD_DEFAULT", SWIG_From_int((int)(wxLOCALE_LOAD_DEFAULT)));
24842 }
24843 {
24844 PyDict_SetItemString(d,"LOCALE_CONV_ENCODING", SWIG_From_int((int)(wxLOCALE_CONV_ENCODING)));
24845 }
24846 {
24847 PyDict_SetItemString(d,"CONVERT_STRICT", SWIG_From_int((int)(wxCONVERT_STRICT)));
24848 }
24849 {
24850 PyDict_SetItemString(d,"CONVERT_SUBSTITUTE", SWIG_From_int((int)(wxCONVERT_SUBSTITUTE)));
24851 }
24852 {
24853 PyDict_SetItemString(d,"PLATFORM_CURRENT", SWIG_From_int((int)(wxPLATFORM_CURRENT)));
24854 }
24855 {
24856 PyDict_SetItemString(d,"PLATFORM_UNIX", SWIG_From_int((int)(wxPLATFORM_UNIX)));
24857 }
24858 {
24859 PyDict_SetItemString(d,"PLATFORM_WINDOWS", SWIG_From_int((int)(wxPLATFORM_WINDOWS)));
24860 }
24861 {
24862 PyDict_SetItemString(d,"PLATFORM_OS2", SWIG_From_int((int)(wxPLATFORM_OS2)));
24863 }
24864 {
24865 PyDict_SetItemString(d,"PLATFORM_MAC", SWIG_From_int((int)(wxPLATFORM_MAC)));
24866 }
24867 {
24868 PyDict_SetItemString(d,"BUFFER_VIRTUAL_AREA", SWIG_From_int((int)(wxBUFFER_VIRTUAL_AREA)));
24869 }
24870 {
24871 PyDict_SetItemString(d,"BUFFER_CLIENT_AREA", SWIG_From_int((int)(wxBUFFER_CLIENT_AREA)));
24872 }
24873 {
24874 PyDict_SetItemString(d,"IMAGELIST_DRAW_NORMAL", SWIG_From_int((int)(wxIMAGELIST_DRAW_NORMAL)));
24875 }
24876 {
24877 PyDict_SetItemString(d,"IMAGELIST_DRAW_TRANSPARENT", SWIG_From_int((int)(wxIMAGELIST_DRAW_TRANSPARENT)));
24878 }
24879 {
24880 PyDict_SetItemString(d,"IMAGELIST_DRAW_SELECTED", SWIG_From_int((int)(wxIMAGELIST_DRAW_SELECTED)));
24881 }
24882 {
24883 PyDict_SetItemString(d,"IMAGELIST_DRAW_FOCUSED", SWIG_From_int((int)(wxIMAGELIST_DRAW_FOCUSED)));
24884 }
24885 {
24886 PyDict_SetItemString(d,"IMAGE_LIST_NORMAL", SWIG_From_int((int)(wxIMAGE_LIST_NORMAL)));
24887 }
24888 {
24889 PyDict_SetItemString(d,"IMAGE_LIST_SMALL", SWIG_From_int((int)(wxIMAGE_LIST_SMALL)));
24890 }
24891 {
24892 PyDict_SetItemString(d,"IMAGE_LIST_STATE", SWIG_From_int((int)(wxIMAGE_LIST_STATE)));
24893 }
24894 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
24895 SWIG_addvarlink(SWIG_globals,(char*)"NORMAL_FONT",_wrap_NORMAL_FONT_get, _wrap_NORMAL_FONT_set);
24896 SWIG_addvarlink(SWIG_globals,(char*)"SMALL_FONT",_wrap_SMALL_FONT_get, _wrap_SMALL_FONT_set);
24897 SWIG_addvarlink(SWIG_globals,(char*)"ITALIC_FONT",_wrap_ITALIC_FONT_get, _wrap_ITALIC_FONT_set);
24898 SWIG_addvarlink(SWIG_globals,(char*)"SWISS_FONT",_wrap_SWISS_FONT_get, _wrap_SWISS_FONT_set);
24899 SWIG_addvarlink(SWIG_globals,(char*)"RED_PEN",_wrap_RED_PEN_get, _wrap_RED_PEN_set);
24900 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_PEN",_wrap_CYAN_PEN_get, _wrap_CYAN_PEN_set);
24901 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_PEN",_wrap_GREEN_PEN_get, _wrap_GREEN_PEN_set);
24902 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_PEN",_wrap_BLACK_PEN_get, _wrap_BLACK_PEN_set);
24903 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_PEN",_wrap_WHITE_PEN_get, _wrap_WHITE_PEN_set);
24904 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_PEN",_wrap_TRANSPARENT_PEN_get, _wrap_TRANSPARENT_PEN_set);
24905 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_DASHED_PEN",_wrap_BLACK_DASHED_PEN_get, _wrap_BLACK_DASHED_PEN_set);
24906 SWIG_addvarlink(SWIG_globals,(char*)"GREY_PEN",_wrap_GREY_PEN_get, _wrap_GREY_PEN_set);
24907 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_PEN",_wrap_MEDIUM_GREY_PEN_get, _wrap_MEDIUM_GREY_PEN_set);
24908 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_PEN",_wrap_LIGHT_GREY_PEN_get, _wrap_LIGHT_GREY_PEN_set);
24909 SWIG_addvarlink(SWIG_globals,(char*)"BLUE_BRUSH",_wrap_BLUE_BRUSH_get, _wrap_BLUE_BRUSH_set);
24910 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_BRUSH",_wrap_GREEN_BRUSH_get, _wrap_GREEN_BRUSH_set);
24911 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_BRUSH",_wrap_WHITE_BRUSH_get, _wrap_WHITE_BRUSH_set);
24912 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_BRUSH",_wrap_BLACK_BRUSH_get, _wrap_BLACK_BRUSH_set);
24913 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_BRUSH",_wrap_TRANSPARENT_BRUSH_get, _wrap_TRANSPARENT_BRUSH_set);
24914 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_BRUSH",_wrap_CYAN_BRUSH_get, _wrap_CYAN_BRUSH_set);
24915 SWIG_addvarlink(SWIG_globals,(char*)"RED_BRUSH",_wrap_RED_BRUSH_get, _wrap_RED_BRUSH_set);
24916 SWIG_addvarlink(SWIG_globals,(char*)"GREY_BRUSH",_wrap_GREY_BRUSH_get, _wrap_GREY_BRUSH_set);
24917 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_BRUSH",_wrap_MEDIUM_GREY_BRUSH_get, _wrap_MEDIUM_GREY_BRUSH_set);
24918 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_BRUSH",_wrap_LIGHT_GREY_BRUSH_get, _wrap_LIGHT_GREY_BRUSH_set);
24919 SWIG_addvarlink(SWIG_globals,(char*)"BLACK",_wrap_BLACK_get, _wrap_BLACK_set);
24920 SWIG_addvarlink(SWIG_globals,(char*)"WHITE",_wrap_WHITE_get, _wrap_WHITE_set);
24921 SWIG_addvarlink(SWIG_globals,(char*)"RED",_wrap_RED_get, _wrap_RED_set);
24922 SWIG_addvarlink(SWIG_globals,(char*)"BLUE",_wrap_BLUE_get, _wrap_BLUE_set);
24923 SWIG_addvarlink(SWIG_globals,(char*)"GREEN",_wrap_GREEN_get, _wrap_GREEN_set);
24924 SWIG_addvarlink(SWIG_globals,(char*)"CYAN",_wrap_CYAN_get, _wrap_CYAN_set);
24925 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY",_wrap_LIGHT_GREY_get, _wrap_LIGHT_GREY_set);
24926 SWIG_addvarlink(SWIG_globals,(char*)"STANDARD_CURSOR",_wrap_STANDARD_CURSOR_get, _wrap_STANDARD_CURSOR_set);
24927 SWIG_addvarlink(SWIG_globals,(char*)"HOURGLASS_CURSOR",_wrap_HOURGLASS_CURSOR_get, _wrap_HOURGLASS_CURSOR_set);
24928 SWIG_addvarlink(SWIG_globals,(char*)"CROSS_CURSOR",_wrap_CROSS_CURSOR_get, _wrap_CROSS_CURSOR_set);
24929 SWIG_addvarlink(SWIG_globals,(char*)"NullBitmap",_wrap_NullBitmap_get, _wrap_NullBitmap_set);
24930 SWIG_addvarlink(SWIG_globals,(char*)"NullIcon",_wrap_NullIcon_get, _wrap_NullIcon_set);
24931 SWIG_addvarlink(SWIG_globals,(char*)"NullCursor",_wrap_NullCursor_get, _wrap_NullCursor_set);
24932 SWIG_addvarlink(SWIG_globals,(char*)"NullPen",_wrap_NullPen_get, _wrap_NullPen_set);
24933 SWIG_addvarlink(SWIG_globals,(char*)"NullBrush",_wrap_NullBrush_get, _wrap_NullBrush_set);
24934 SWIG_addvarlink(SWIG_globals,(char*)"NullPalette",_wrap_NullPalette_get, _wrap_NullPalette_set);
24935 SWIG_addvarlink(SWIG_globals,(char*)"NullFont",_wrap_NullFont_get, _wrap_NullFont_set);
24936 SWIG_addvarlink(SWIG_globals,(char*)"NullColour",_wrap_NullColour_get, _wrap_NullColour_set);
24937 SWIG_addvarlink(SWIG_globals,(char*)"TheFontList",_wrap_TheFontList_get, _wrap_TheFontList_set);
24938 SWIG_addvarlink(SWIG_globals,(char*)"ThePenList",_wrap_ThePenList_get, _wrap_ThePenList_set);
24939 SWIG_addvarlink(SWIG_globals,(char*)"TheBrushList",_wrap_TheBrushList_get, _wrap_TheBrushList_set);
24940 SWIG_addvarlink(SWIG_globals,(char*)"TheColourDatabase",_wrap_TheColourDatabase_get, _wrap_TheColourDatabase_set);
24941 {
24942 PyDict_SetItemString(d,"CONTROL_DISABLED", SWIG_From_int((int)(wxCONTROL_DISABLED)));
24943 }
24944 {
24945 PyDict_SetItemString(d,"CONTROL_FOCUSED", SWIG_From_int((int)(wxCONTROL_FOCUSED)));
24946 }
24947 {
24948 PyDict_SetItemString(d,"CONTROL_PRESSED", SWIG_From_int((int)(wxCONTROL_PRESSED)));
24949 }
24950 {
24951 PyDict_SetItemString(d,"CONTROL_ISDEFAULT", SWIG_From_int((int)(wxCONTROL_ISDEFAULT)));
24952 }
24953 {
24954 PyDict_SetItemString(d,"CONTROL_ISSUBMENU", SWIG_From_int((int)(wxCONTROL_ISSUBMENU)));
24955 }
24956 {
24957 PyDict_SetItemString(d,"CONTROL_EXPANDED", SWIG_From_int((int)(wxCONTROL_EXPANDED)));
24958 }
24959 {
24960 PyDict_SetItemString(d,"CONTROL_CURRENT", SWIG_From_int((int)(wxCONTROL_CURRENT)));
24961 }
24962 {
24963 PyDict_SetItemString(d,"CONTROL_SELECTED", SWIG_From_int((int)(wxCONTROL_SELECTED)));
24964 }
24965 {
24966 PyDict_SetItemString(d,"CONTROL_CHECKED", SWIG_From_int((int)(wxCONTROL_CHECKED)));
24967 }
24968 {
24969 PyDict_SetItemString(d,"CONTROL_CHECKABLE", SWIG_From_int((int)(wxCONTROL_CHECKABLE)));
24970 }
24971 {
24972 PyDict_SetItemString(d,"CONTROL_UNDETERMINED", SWIG_From_int((int)(wxCONTROL_UNDETERMINED)));
24973 }
24974 {
24975 PyDict_SetItemString(d,"CONTROL_FLAGS_MASK", SWIG_From_int((int)(wxCONTROL_FLAGS_MASK)));
24976 }
24977 {
24978 PyDict_SetItemString(d,"CONTROL_DIRTY", SWIG_From_int((int)(wxCONTROL_DIRTY)));
24979 }
24980 {
24981 PyDict_SetItemString(d,"RendererVersion_Current_Version", SWIG_From_int((int)(wxRendererVersion::Current_Version)));
24982 }
24983 {
24984 PyDict_SetItemString(d,"RendererVersion_Current_Age", SWIG_From_int((int)(wxRendererVersion::Current_Age)));
24985 }
24986
24987 // Work around a chicken/egg problem in drawlist.cpp
24988 wxPyDrawList_SetAPIPtr();
24989
24990 }
24991
wxWidgets (Impactor)