]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_gdi_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
cleanup - reformat ()
[wxWidgets.git] / wxPython / src / mac / _gdi_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 if (str)
1041 Py_DECREF(str);
1042 return;
1043 }
1044 }
1045 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1046 } else {
1047 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1048 }
1049 }
1050
1051 SWIGRUNTIMEINLINE void
1052 SWIG_Python_NullRef(const char *type)
1053 {
1054 if (type) {
1055 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1056 } else {
1057 PyErr_Format(PyExc_TypeError, "null reference was received");
1058 }
1059 }
1060
1061 SWIGRUNTIME int
1062 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1063 {
1064 if (PyErr_Occurred()) {
1065 PyObject *type = 0;
1066 PyObject *value = 0;
1067 PyObject *traceback = 0;
1068 PyErr_Fetch(&type, &value, &traceback);
1069 if (value) {
1070 PyObject *old_str = PyObject_Str(value);
1071 Py_XINCREF(type);
1072 PyErr_Clear();
1073 if (infront) {
1074 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1075 } else {
1076 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1077 }
1078 Py_DECREF(old_str);
1079 }
1080 return 1;
1081 } else {
1082 return 0;
1083 }
1084 }
1085
1086 SWIGRUNTIME int
1087 SWIG_Python_ArgFail(int argnum)
1088 {
1089 if (PyErr_Occurred()) {
1090 /* add information about failing argument */
1091 char mesg[256];
1092 sprintf(mesg, "argument number %d:", argnum);
1093 return SWIG_Python_AddErrMesg(mesg, 1);
1094 } else {
1095 return 0;
1096 }
1097 }
1098
1099
1100 /* -----------------------------------------------------------------------------
1101 * pointers/data manipulation
1102 * ----------------------------------------------------------------------------- */
1103
1104 /* Convert a pointer value */
1105 SWIGRUNTIME int
1106 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1107 swig_type_info *tc;
1108 const char *c = 0;
1109 static PyObject *SWIG_this = 0;
1110 int newref = 0;
1111 PyObject *pyobj = 0;
1112 void *vptr;
1113
1114 if (!obj) return 0;
1115 if (obj == Py_None) {
1116 *ptr = 0;
1117 return 0;
1118 }
1119
1120 #ifdef SWIG_COBJECT_TYPES
1121 if (!(PySwigObject_Check(obj))) {
1122 if (!SWIG_this)
1123 SWIG_this = PyString_FromString("this");
1124 pyobj = obj;
1125 obj = PyObject_GetAttr(obj,SWIG_this);
1126 newref = 1;
1127 if (!obj) goto type_error;
1128 if (!PySwigObject_Check(obj)) {
1129 Py_DECREF(obj);
1130 goto type_error;
1131 }
1132 }
1133 vptr = PySwigObject_AsVoidPtr(obj);
1134 c = (const char *) PySwigObject_GetDesc(obj);
1135 if (newref) { Py_DECREF(obj); }
1136 goto type_check;
1137 #else
1138 if (!(PyString_Check(obj))) {
1139 if (!SWIG_this)
1140 SWIG_this = PyString_FromString("this");
1141 pyobj = obj;
1142 obj = PyObject_GetAttr(obj,SWIG_this);
1143 newref = 1;
1144 if (!obj) goto type_error;
1145 if (!PyString_Check(obj)) {
1146 Py_DECREF(obj);
1147 goto type_error;
1148 }
1149 }
1150 c = PyString_AS_STRING(obj);
1151 /* Pointer values must start with leading underscore */
1152 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1153 if (newref) { Py_DECREF(obj); }
1154 if (!c) goto type_error;
1155 #endif
1156
1157 type_check:
1158
1159 if (ty) {
1160 tc = SWIG_TypeCheck(c,ty);
1161 if (!tc) goto type_error;
1162 *ptr = SWIG_TypeCast(tc,vptr);
1163 } else {
1164 *ptr = vptr;
1165 }
1166
1167 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1168 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1169 }
1170 return 0;
1171
1172 type_error:
1173 PyErr_Clear();
1174 if (pyobj && !obj) {
1175 obj = pyobj;
1176 if (PyCFunction_Check(obj)) {
1177 /* here we get the method pointer for callbacks */
1178 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1179 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1180 if (c) {
1181 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1182 if (!c) goto type_error;
1183 goto type_check;
1184 }
1185 }
1186 }
1187 if (flags & SWIG_POINTER_EXCEPTION) {
1188 if (ty) {
1189 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1190 } else {
1191 SWIG_Python_TypeError("C/C++ pointer", obj);
1192 }
1193 }
1194 return -1;
1195 }
1196
1197 /* Convert a pointer value, signal an exception on a type mismatch */
1198 SWIGRUNTIME void *
1199 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1200 void *result;
1201 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1202 PyErr_Clear();
1203 if (flags & SWIG_POINTER_EXCEPTION) {
1204 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1205 SWIG_Python_ArgFail(argnum);
1206 }
1207 }
1208 return result;
1209 }
1210
1211 /* Convert a packed value value */
1212 SWIGRUNTIME int
1213 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1214 swig_type_info *tc;
1215 const char *c = 0;
1216
1217 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1218 c = PySwigPacked_UnpackData(obj, ptr, sz);
1219 #else
1220 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1221 c = PyString_AS_STRING(obj);
1222 /* Pointer values must start with leading underscore */
1223 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1224 #endif
1225 if (!c) goto type_error;
1226 if (ty) {
1227 tc = SWIG_TypeCheck(c,ty);
1228 if (!tc) goto type_error;
1229 }
1230 return 0;
1231
1232 type_error:
1233 PyErr_Clear();
1234 if (flags & SWIG_POINTER_EXCEPTION) {
1235 if (ty) {
1236 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1237 } else {
1238 SWIG_Python_TypeError("C/C++ packed data", obj);
1239 }
1240 }
1241 return -1;
1242 }
1243
1244 /* Create a new array object */
1245 SWIGRUNTIME PyObject *
1246 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1247 PyObject *robj = 0;
1248 if (!ptr) {
1249 Py_INCREF(Py_None);
1250 return Py_None;
1251 }
1252 #ifdef SWIG_COBJECT_TYPES
1253 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1254 #else
1255 {
1256 char result[SWIG_BUFFER_SIZE];
1257 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1258 PyString_FromString(result) : 0;
1259 }
1260 #endif
1261 if (!robj || (robj == Py_None)) return robj;
1262 if (type->clientdata) {
1263 PyObject *inst;
1264 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1265 Py_DECREF(robj);
1266 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1267 Py_DECREF(args);
1268 if (inst) {
1269 if (own) {
1270 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1271 }
1272 robj = inst;
1273 }
1274 }
1275 return robj;
1276 }
1277
1278 SWIGRUNTIME PyObject *
1279 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1280 PyObject *robj = 0;
1281 if (!ptr) {
1282 Py_INCREF(Py_None);
1283 return Py_None;
1284 }
1285 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1286 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1287 #else
1288 {
1289 char result[SWIG_BUFFER_SIZE];
1290 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1291 PyString_FromString(result) : 0;
1292 }
1293 #endif
1294 return robj;
1295 }
1296
1297 /* -----------------------------------------------------------------------------*
1298 * Get type list
1299 * -----------------------------------------------------------------------------*/
1300
1301 #ifdef SWIG_LINK_RUNTIME
1302 void *SWIG_ReturnGlobalTypeList(void *);
1303 #endif
1304
1305 SWIGRUNTIME swig_type_info **
1306 SWIG_Python_GetTypeListHandle() {
1307 static void *type_pointer = (void *)0;
1308 /* first check if module already created */
1309 if (!type_pointer) {
1310 #ifdef SWIG_LINK_RUNTIME
1311 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1312 #else
1313 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1314 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1315 if (PyErr_Occurred()) {
1316 PyErr_Clear();
1317 type_pointer = (void *)0;
1318 }
1319 }
1320 #endif
1321 return (swig_type_info **) type_pointer;
1322 }
1323
1324 /*
1325 Search for a swig_type_info structure
1326 */
1327 SWIGRUNTIMEINLINE swig_type_info *
1328 SWIG_Python_GetTypeList() {
1329 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1330 return tlh ? *tlh : (swig_type_info*)0;
1331 }
1332
1333 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1334
1335 #ifdef __cplusplus
1336 }
1337 #endif
1338
1339
1340 /* -------- TYPES TABLE (BEGIN) -------- */
1341
1342 #define SWIGTYPE_p_wxPostScriptDC swig_types[0]
1343 #define SWIGTYPE_p_wxBrush swig_types[1]
1344 #define SWIGTYPE_p_wxColour swig_types[2]
1345 #define SWIGTYPE_p_wxDC swig_types[3]
1346 #define SWIGTYPE_p_wxMirrorDC swig_types[4]
1347 #define SWIGTYPE_p_form_ops_t swig_types[5]
1348 #define SWIGTYPE_p_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_wxLanguageInfo swig_types[47]
1390 #define SWIGTYPE_p_wxWindowDC swig_types[48]
1391 #define SWIGTYPE_p_wxPrintData swig_types[49]
1392 #define SWIGTYPE_p_wxBrushList swig_types[50]
1393 #define SWIGTYPE_p_wxFontList swig_types[51]
1394 #define SWIGTYPE_p_wxPen swig_types[52]
1395 #define SWIGTYPE_p_wxBufferedPaintDC swig_types[53]
1396 #define SWIGTYPE_p_wxPaintDC swig_types[54]
1397 #define SWIGTYPE_p_wxPenList swig_types[55]
1398 #define SWIGTYPE_p_int swig_types[56]
1399 #define SWIGTYPE_p_wxMetaFile swig_types[57]
1400 #define SWIGTYPE_p_wxRendererNative swig_types[58]
1401 #define SWIGTYPE_p_unsigned_long swig_types[59]
1402 #define SWIGTYPE_p_wxNativeFontInfo swig_types[60]
1403 #define SWIGTYPE_p_wxEncodingConverter swig_types[61]
1404 #define SWIGTYPE_p_wxSplitterRenderParams swig_types[62]
1405 #define SWIGTYPE_p_wxColourDatabase swig_types[63]
1406 static swig_type_info *swig_types[65];
1407
1408 /* -------- TYPES TABLE (END) -------- */
1409
1410
1411 /*-----------------------------------------------
1412 @(target):= _gdi_.so
1413 ------------------------------------------------*/
1414 #define SWIG_init init_gdi_
1415
1416 #define SWIG_name "_gdi_"
1417
1418 #include "wx/wxPython/wxPython.h"
1419 #include "wx/wxPython/pyclasses.h"
1420
1421
1422 static const wxString wxPyEmptyString(wxEmptyString);
1423
1424 #include <limits.h>
1425
1426
1427 SWIGINTERN int
1428 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1429 const char *errmsg)
1430 {
1431 if (value < min_value) {
1432 if (errmsg) {
1433 PyErr_Format(PyExc_OverflowError,
1434 "value %ld is less than '%s' minimum %ld",
1435 value, errmsg, min_value);
1436 }
1437 return 0;
1438 } else if (value > max_value) {
1439 if (errmsg) {
1440 PyErr_Format(PyExc_OverflowError,
1441 "value %ld is greater than '%s' maximum %ld",
1442 value, errmsg, max_value);
1443 }
1444 return 0;
1445 }
1446 return 1;
1447 }
1448
1449
1450 SWIGINTERN int
1451 SWIG_AsVal_long(PyObject* obj, long* val)
1452 {
1453 if (PyNumber_Check(obj)) {
1454 if (val) *val = PyInt_AsLong(obj);
1455 return 1;
1456 }
1457 else {
1458 SWIG_type_error("number", obj);
1459 }
1460 return 0;
1461 }
1462
1463
1464 #if INT_MAX != LONG_MAX
1465 SWIGINTERN int
1466 SWIG_AsVal_int(PyObject *obj, int *val)
1467 {
1468 const char* errmsg = val ? "int" : (char*)0;
1469 long v;
1470 if (SWIG_AsVal_long(obj, &v)) {
1471 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1472 if (val) *val = (int)(v);
1473 return 1;
1474 } else {
1475 return 0;
1476 }
1477 } else {
1478 PyErr_Clear();
1479 }
1480 if (val) {
1481 SWIG_type_error(errmsg, obj);
1482 }
1483 return 0;
1484 }
1485 #else
1486 SWIGINTERNSHORT int
1487 SWIG_AsVal_int(PyObject *obj, int *val)
1488 {
1489 return SWIG_AsVal_long(obj,(long*)val);
1490 }
1491 #endif
1492
1493
1494 SWIGINTERN int
1495 SWIG_AsVal_bool(PyObject *obj, bool *val)
1496 {
1497 if (obj == Py_True) {
1498 if (val) *val = true;
1499 return 1;
1500 }
1501 if (obj == Py_False) {
1502 if (val) *val = false;
1503 return 1;
1504 }
1505 int res = 0;
1506 if (SWIG_AsVal_int(obj, &res)) {
1507 if (val) *val = res ? true : false;
1508 return 1;
1509 } else {
1510 PyErr_Clear();
1511 }
1512 if (val) {
1513 SWIG_type_error("bool", obj);
1514 }
1515 return 0;
1516 }
1517
1518
1519 SWIGINTERNSHORT bool
1520 SWIG_As_bool(PyObject* obj)
1521 {
1522 bool v;
1523 if (!SWIG_AsVal_bool(obj, &v)) {
1524 /*
1525 this is needed to make valgrind/purify happier.
1526 */
1527 memset((void*)&v, 0, sizeof(bool));
1528 }
1529 return v;
1530 }
1531
1532
1533 SWIGINTERNSHORT int
1534 SWIG_Check_bool(PyObject* obj)
1535 {
1536 return SWIG_AsVal_bool(obj, (bool*)0);
1537 }
1538
1539
1540 SWIGINTERN int
1541 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1542 {
1543 long v = 0;
1544 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1545 SWIG_type_error("unsigned number", obj);
1546 }
1547 else if (val)
1548 *val = (unsigned long)v;
1549 return 1;
1550 }
1551
1552
1553 SWIGINTERNSHORT int
1554 SWIG_CheckUnsignedLongInRange(unsigned long value,
1555 unsigned long max_value,
1556 const char *errmsg)
1557 {
1558 if (value > max_value) {
1559 if (errmsg) {
1560 PyErr_Format(PyExc_OverflowError,
1561 "value %lu is greater than '%s' minimum %lu",
1562 value, errmsg, max_value);
1563 }
1564 return 0;
1565 }
1566 return 1;
1567 }
1568
1569
1570 SWIGINTERN int
1571 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
1572 {
1573 const char* errmsg = val ? "unsigned char" : (char*)0;
1574 unsigned long v;
1575 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1576 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
1577 if (val) *val = (unsigned char)(v);
1578 return 1;
1579 } else {
1580 return 0;
1581 }
1582 } else {
1583 PyErr_Clear();
1584 }
1585 if (val) {
1586 SWIG_type_error(errmsg, obj);
1587 }
1588 return 0;
1589 }
1590
1591
1592 SWIGINTERNSHORT unsigned char
1593 SWIG_As_unsigned_SS_char(PyObject* obj)
1594 {
1595 unsigned char v;
1596 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
1597 /*
1598 this is needed to make valgrind/purify happier.
1599 */
1600 memset((void*)&v, 0, sizeof(unsigned char));
1601 }
1602 return v;
1603 }
1604
1605
1606 SWIGINTERNSHORT int
1607 SWIG_Check_unsigned_SS_char(PyObject* obj)
1608 {
1609 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
1610 }
1611
1612
1613 SWIGINTERNSHORT unsigned long
1614 SWIG_As_unsigned_SS_long(PyObject* obj)
1615 {
1616 unsigned long v;
1617 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1618 /*
1619 this is needed to make valgrind/purify happier.
1620 */
1621 memset((void*)&v, 0, sizeof(unsigned long));
1622 }
1623 return v;
1624 }
1625
1626
1627 SWIGINTERNSHORT int
1628 SWIG_Check_unsigned_SS_long(PyObject* obj)
1629 {
1630 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1631 }
1632
1633
1634 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1635 #define SWIG_From_unsigned_SS_char PyInt_FromLong
1636 /*@@*/
1637
1638
1639 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1640 #define SWIG_From_long PyInt_FromLong
1641 /*@@*/
1642
1643 static PyObject *wxColour_Get(wxColour *self){
1644 PyObject* rv = PyTuple_New(3);
1645 int red = -1;
1646 int green = -1;
1647 int blue = -1;
1648 if (self->Ok()) {
1649 red = self->Red();
1650 green = self->Green();
1651 blue = self->Blue();
1652 }
1653 PyTuple_SetItem(rv, 0, PyInt_FromLong(red));
1654 PyTuple_SetItem(rv, 1, PyInt_FromLong(green));
1655 PyTuple_SetItem(rv, 2, PyInt_FromLong(blue));
1656 return rv;
1657 }
1658 static unsigned long wxColour_GetRGB(wxColour *self){
1659 return self->Red() | (self->Green() << 8) | (self->Blue() << 16);
1660 }
1661
1662 SWIGINTERNSHORT PyObject*
1663 SWIG_From_unsigned_SS_long(unsigned long value)
1664 {
1665 return (value > LONG_MAX) ?
1666 PyLong_FromUnsignedLong(value)
1667 : PyInt_FromLong((long)(value));
1668 }
1669
1670
1671 SWIGINTERNSHORT int
1672 SWIG_As_int(PyObject* obj)
1673 {
1674 int v;
1675 if (!SWIG_AsVal_int(obj, &v)) {
1676 /*
1677 this is needed to make valgrind/purify happier.
1678 */
1679 memset((void*)&v, 0, sizeof(int));
1680 }
1681 return v;
1682 }
1683
1684
1685 SWIGINTERNSHORT int
1686 SWIG_Check_int(PyObject* obj)
1687 {
1688 return SWIG_AsVal_int(obj, (int*)0);
1689 }
1690
1691
1692 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1693 #define SWIG_From_int PyInt_FromLong
1694 /*@@*/
1695
1696
1697 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1698 PyObject* o2;
1699 PyObject* o3;
1700
1701 if (!target) {
1702 target = o;
1703 } else if (target == Py_None) {
1704 Py_DECREF(Py_None);
1705 target = o;
1706 } else {
1707 if (!PyTuple_Check(target)) {
1708 o2 = target;
1709 target = PyTuple_New(1);
1710 PyTuple_SetItem(target, 0, o2);
1711 }
1712 o3 = PyTuple_New(1);
1713 PyTuple_SetItem(o3, 0, o);
1714
1715 o2 = target;
1716 target = PySequence_Concat(o2, o3);
1717 Py_DECREF(o2);
1718 Py_DECREF(o3);
1719 }
1720 return target;
1721 }
1722
1723
1724 static PyObject *wxPen_GetDashes(wxPen *self){
1725 wxDash* dashes;
1726 int count = self->GetDashes(&dashes);
1727 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1728 PyObject* retval = PyList_New(0);
1729 for (int x=0; x<count; x++) {
1730 PyObject* pyint = PyInt_FromLong(dashes[x]);
1731 PyList_Append(retval, pyint);
1732 Py_DECREF(pyint);
1733 }
1734 wxPyEndBlockThreads(blocked);
1735 return retval;
1736 }
1737 static void wxPen__SetDashes(wxPen *self,PyObject *_self,PyObject *pyDashes){
1738 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1739 int size = PyList_Size(pyDashes);
1740 wxDash* dashes = (wxDash*)byte_LIST_helper(pyDashes);
1741
1742 // black magic warning! The array of wxDashes needs to exist as
1743 // long as the pen does because wxPen does not copy the array. So
1744 // stick a copy in a Python string object and attach it to _self,
1745 // and then call SetDashes with a pointer to that array. Then
1746 // when the Python pen object is destroyed the array will be
1747 // cleaned up too.
1748 PyObject* strDashes = PyString_FromStringAndSize((char*)dashes, size*sizeof(wxDash));
1749 PyObject_SetAttrString(_self, "_dashes", strDashes);
1750
1751 self->SetDashes(size, (wxDash*)PyString_AS_STRING(strDashes));
1752 delete [] dashes;
1753 Py_DECREF(strDashes);
1754 wxPyEndBlockThreads(blocked);
1755 }
1756 static bool wxPen___eq__(wxPen *self,wxPen const *other){ return other ? (*self == *other) : false; }
1757 static bool wxPen___ne__(wxPen *self,wxPen const *other){ return other ? (*self != *other) : true; }
1758
1759 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1760 #define SWIG_From_short PyInt_FromLong
1761 /*@@*/
1762
1763
1764 SWIGINTERN int
1765 SWIG_AsVal_short(PyObject *obj, short *val)
1766 {
1767 const char* errmsg = val ? "short" : (char*)0;
1768 long v;
1769 if (SWIG_AsVal_long(obj, &v)) {
1770 if (SWIG_CheckLongInRange(v, SHRT_MIN, SHRT_MAX, errmsg)) {
1771 if (val) *val = (short)(v);
1772 return 1;
1773 } else {
1774 return 0;
1775 }
1776 } else {
1777 PyErr_Clear();
1778 }
1779 if (val) {
1780 SWIG_type_error(errmsg, obj);
1781 }
1782 return 0;
1783 }
1784
1785
1786 SWIGINTERNSHORT short
1787 SWIG_As_short(PyObject* obj)
1788 {
1789 short v;
1790 if (!SWIG_AsVal_short(obj, &v)) {
1791 /*
1792 this is needed to make valgrind/purify happier.
1793 */
1794 memset((void*)&v, 0, sizeof(short));
1795 }
1796 return v;
1797 }
1798
1799
1800 SWIGINTERNSHORT int
1801 SWIG_Check_short(PyObject* obj)
1802 {
1803 return SWIG_AsVal_short(obj, (short*)0);
1804 }
1805
1806
1807 #include <wx/image.h>
1808
1809 static char** ConvertListOfStrings(PyObject* listOfStrings) {
1810 char** cArray = NULL;
1811 int count;
1812
1813 if (!PyList_Check(listOfStrings)) {
1814 PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
1815 return NULL;
1816 }
1817 count = PyList_Size(listOfStrings);
1818 cArray = new char*[count];
1819
1820 for(int x=0; x<count; x++) {
1821 // TODO: Need some validation and error checking here
1822 cArray[x] = PyString_AsString(PyList_GET_ITEM(listOfStrings, x));
1823 }
1824 return cArray;
1825 }
1826
1827
1828 static wxBitmap *new_wxBitmap(PyObject *listOfStrings){
1829 char** cArray = NULL;
1830 wxBitmap* bmp;
1831
1832 cArray = ConvertListOfStrings(listOfStrings);
1833 if (! cArray)
1834 return NULL;
1835 bmp = new wxBitmap(cArray);
1836 delete [] cArray;
1837 return bmp;
1838 }
1839 static wxBitmap *new_wxBitmap(PyObject *bits,int width,int height,int depth=1){
1840 char* buf;
1841 int length;
1842 PyString_AsStringAndSize(bits, &buf, &length);
1843 return new wxBitmap(buf, width, height, depth);
1844 }
1845 static wxSize wxBitmap_GetSize(wxBitmap *self){
1846 wxSize size(self->GetWidth(), self->GetHeight());
1847 return size;
1848 }
1849 static void wxBitmap_SetMaskColour(wxBitmap *self,wxColour const &colour){
1850 wxMask *mask = new wxMask(*self, colour);
1851 self->SetMask(mask);
1852 }
1853 static void wxBitmap_SetSize(wxBitmap *self,wxSize const &size){
1854 self->SetWidth(size.x);
1855 self->SetHeight(size.y);
1856 }
1857 static bool wxBitmap___eq__(wxBitmap *self,wxBitmap const *other){ return other ? (*self == *other) : false; }
1858 static bool wxBitmap___ne__(wxBitmap *self,wxBitmap const *other){ return other ? (*self != *other) : true; }
1859 static wxMask *new_wxMask(wxBitmap const &bitmap,wxColour const &colour=wxNullColour){
1860 if ( !colour.Ok() )
1861 return new wxMask(bitmap, *wxBLACK);
1862 else
1863 return new wxMask(bitmap, colour);
1864 }
1865
1866 #include <wx/iconbndl.h>
1867
1868 static wxIcon *new_wxIcon(wxBitmap const &bmp){
1869 wxIcon* icon = new wxIcon();
1870 icon->CopyFromBitmap(bmp);
1871 return icon;
1872 }
1873 static wxIcon *new_wxIcon(PyObject *listOfStrings){
1874 char** cArray = NULL;
1875 wxIcon* icon;
1876
1877 cArray = ConvertListOfStrings(listOfStrings);
1878 if (! cArray)
1879 return NULL;
1880 icon = new wxIcon(cArray);
1881 delete [] cArray;
1882 return icon;
1883 }
1884 static wxIconLocation *new_wxIconLocation(wxString const *filename=&wxPyEmptyString,int num=0){
1885
1886
1887
1888 return new wxIconLocation(*filename);
1889
1890 }
1891 static void wxIconLocation_SetIndex(wxIconLocation *self,int num){
1892
1893
1894
1895 // do nothing
1896
1897 }
1898 static int wxIconLocation_GetIndex(wxIconLocation *self){
1899
1900
1901
1902 return -1;
1903
1904 }
1905
1906 SWIGINTERNSHORT long
1907 SWIG_As_long(PyObject* obj)
1908 {
1909 long v;
1910 if (!SWIG_AsVal_long(obj, &v)) {
1911 /*
1912 this is needed to make valgrind/purify happier.
1913 */
1914 memset((void*)&v, 0, sizeof(long));
1915 }
1916 return v;
1917 }
1918
1919
1920 SWIGINTERNSHORT int
1921 SWIG_Check_long(PyObject* obj)
1922 {
1923 return SWIG_AsVal_long(obj, (long*)0);
1924 }
1925
1926 static wxCursor *new_wxCursor(wxString const &cursorName,long type,int hotSpotX=0,int hotSpotY=0){
1927 #ifdef __WXGTK__
1928 wxImage img(cursorName, type);
1929 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, hotSpotX);
1930 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, hotSpotY);
1931 return new wxCursor(img);
1932 #else
1933 return new wxCursor(cursorName, type, hotSpotX, hotSpotY);
1934 #endif
1935 }
1936
1937
1938 static void wxRegionIterator_Next(wxRegionIterator *self){
1939 (*self) ++;
1940 }
1941 static bool wxRegionIterator___nonzero__(wxRegionIterator *self){
1942 return self->operator bool();
1943 }
1944
1945 #include <wx/fontutil.h>
1946 #include <wx/fontmap.h>
1947 #include <wx/fontenum.h>
1948
1949 static wxString wxNativeFontInfo___str__(wxNativeFontInfo *self){
1950 return self->ToString();
1951 }
1952
1953 wxNativeEncodingInfo* wxGetNativeFontEncoding(wxFontEncoding encoding) {
1954 static wxNativeEncodingInfo info;
1955 if ( wxGetNativeFontEncoding(encoding, &info) )
1956 return &info;
1957 else
1958 return NULL;
1959 }
1960
1961 static PyObject *wxFontMapper_GetAltForEncoding(wxFontMapper *self,wxFontEncoding encoding,wxString const &facename=wxPyEmptyString,bool interactive=true){
1962 wxFontEncoding alt_enc;
1963 if (self->GetAltForEncoding(encoding, &alt_enc, facename, interactive))
1964 return PyInt_FromLong(alt_enc);
1965 else {
1966 Py_INCREF(Py_None);
1967 return Py_None;
1968 }
1969 }
1970 static wxFont *new_wxFont(wxString const &info){
1971 wxNativeFontInfo nfi;
1972 nfi.FromString(info);
1973 return new wxFont(nfi);
1974 }
1975 static wxFont *new_wxFont(int pointSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxPyEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1976 return wxFont::New(pointSize, family, flags, face, encoding);
1977 }
1978 static wxFont *new_wxFont(wxSize const &pixelSize,int family,int style,int weight,bool underlined=false,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1979 return wxFontBase::New(pixelSize, family,
1980 style, weight, underlined,
1981 face, encoding);
1982 }
1983 static wxFont *new_wxFont(wxSize const &pixelSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1984 return wxFontBase::New(pixelSize, family, flags, face, encoding);
1985 }
1986 static bool wxFont___eq__(wxFont *self,wxFont const *other){ return other ? (*self == *other) : false; }
1987 static bool wxFont___ne__(wxFont *self,wxFont const *other){ return other ? (*self != *other) : true; }
1988
1989 class wxPyFontEnumerator : public wxFontEnumerator {
1990 public:
1991 wxPyFontEnumerator() {}
1992 ~wxPyFontEnumerator() {}
1993
1994 DEC_PYCALLBACK_BOOL_STRING(OnFacename);
1995 DEC_PYCALLBACK_BOOL_STRINGSTRING(OnFontEncoding);
1996
1997 PYPRIVATE;
1998 };
1999
2000 IMP_PYCALLBACK_BOOL_STRING(wxPyFontEnumerator, wxFontEnumerator, OnFacename);
2001 IMP_PYCALLBACK_BOOL_STRINGSTRING(wxPyFontEnumerator, wxFontEnumerator, OnFontEncoding);
2002
2003
2004 static PyObject *wxPyFontEnumerator_GetEncodings(wxPyFontEnumerator *self){
2005 wxArrayString* arr = self->GetEncodings();
2006 if (arr)
2007 return wxArrayString2PyList_helper(*arr);
2008 else
2009 return PyList_New(0);
2010 }
2011 static PyObject *wxPyFontEnumerator_GetFacenames(wxPyFontEnumerator *self){
2012 wxArrayString* arr = self->GetFacenames();
2013 if (arr)
2014 return wxArrayString2PyList_helper(*arr);
2015 else
2016 return PyList_New(0);
2017 }
2018
2019 #include <locale.h>
2020
2021 static wxLocale *new_wxLocale(int language=-1,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
2022 wxLocale* loc;
2023 if (language == -1)
2024 loc = new wxLocale();
2025 else
2026 loc = new wxLocale(language, flags);
2027 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
2028 // for the floating point conversions and such to work right.
2029 #if PY_VERSION_HEX < 0x02040000
2030 setlocale(LC_NUMERIC, "C");
2031 #endif
2032 return loc;
2033 }
2034 static bool wxLocale_Init1(wxLocale *self,wxString const &szName,wxString const &szShort=wxPyEmptyString,wxString const &szLocale=wxPyEmptyString,bool bLoadDefault=true,bool bConvertEncoding=false){
2035 bool rc = self->Init(szName, szShort, szLocale, bLoadDefault, bConvertEncoding);
2036 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
2037 // for the floating point conversions and such to work right.
2038 #if PY_VERSION_HEX < 0x02040000
2039 setlocale(LC_NUMERIC, "C");
2040 #endif
2041 return rc;
2042 }
2043 static bool wxLocale_Init2(wxLocale *self,int language=wxLANGUAGE_DEFAULT,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
2044 bool rc = self->Init(language, flags);
2045 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
2046 // for the floating point conversions and such to work right.
2047 #if PY_VERSION_HEX < 0x02040000
2048 setlocale(LC_NUMERIC, "C");
2049 #endif
2050 return rc;
2051 }
2052
2053 #include "wx/wxPython/pydrawxxx.h"
2054
2055 static wxColour wxDC_GetPixel(wxDC *self,int x,int y){
2056 wxColour col;
2057 self->GetPixel(x, y, &col);
2058 return col;
2059 }
2060 static wxColour wxDC_GetPixelPoint(wxDC *self,wxPoint const &pt){
2061 wxColour col;
2062 self->GetPixel(pt, &col);
2063 return col;
2064 }
2065
2066 SWIGINTERN int
2067 SWIG_AsVal_double(PyObject *obj, double* val)
2068 {
2069 if (PyNumber_Check(obj)) {
2070 if (val) *val = PyFloat_AsDouble(obj);
2071 return 1;
2072 }
2073 else {
2074 SWIG_type_error("number", obj);
2075 }
2076 return 0;
2077 }
2078
2079
2080 SWIGINTERNSHORT double
2081 SWIG_As_double(PyObject* obj)
2082 {
2083 double v;
2084 if (!SWIG_AsVal_double(obj, &v)) {
2085 /*
2086 this is needed to make valgrind/purify happier.
2087 */
2088 memset((void*)&v, 0, sizeof(double));
2089 }
2090 return v;
2091 }
2092
2093
2094 SWIGINTERNSHORT int
2095 SWIG_Check_double(PyObject* obj)
2096 {
2097 return SWIG_AsVal_double(obj, (double*)0);
2098 }
2099
2100 static wxRect wxDC_DrawImageLabel(wxDC *self,wxString const &text,wxBitmap const &image,wxRect const &rect,int alignment=wxALIGN_LEFT|wxALIGN_TOP,int indexAccel=-1){
2101 wxRect rv;
2102 self->DrawLabel(text, image, rect, alignment, indexAccel, &rv);
2103 return rv;
2104 }
2105
2106 static wxRect wxDC_GetClippingRect(wxDC *self){
2107 wxRect rect;
2108 self->GetClippingBox(rect);
2109 return rect;
2110 }
2111 static wxArrayInt wxDC_GetPartialTextExtents(wxDC *self,wxString const &text){
2112 wxArrayInt widths;
2113 self->GetPartialTextExtents(text, widths);
2114 return widths;
2115 }
2116
2117 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2118 #define SWIG_From_double PyFloat_FromDouble
2119 /*@@*/
2120
2121
2122 static void wxDC_SetLogicalOriginPoint(wxDC *self,wxPoint const &point){
2123 self->SetLogicalOrigin(point.x, point.y);
2124 }
2125 static void wxDC_SetDeviceOriginPoint(wxDC *self,wxPoint const &point){
2126 self->SetDeviceOrigin(point.x, point.y);
2127 }
2128 static void wxDC_CalcBoundingBoxPoint(wxDC *self,wxPoint const &point){
2129 self->CalcBoundingBox(point.x, point.y);
2130 }
2131 static PyObject *wxDC__DrawPointList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2132 return wxPyDrawXXXList(*self, wxPyDrawXXXPoint, pyCoords, pyPens, pyBrushes);
2133 }
2134 static PyObject *wxDC__DrawLineList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2135 return wxPyDrawXXXList(*self, wxPyDrawXXXLine, pyCoords, pyPens, pyBrushes);
2136 }
2137 static PyObject *wxDC__DrawRectangleList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2138 return wxPyDrawXXXList(*self, wxPyDrawXXXRectangle, pyCoords, pyPens, pyBrushes);
2139 }
2140 static PyObject *wxDC__DrawEllipseList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2141 return wxPyDrawXXXList(*self, wxPyDrawXXXEllipse, pyCoords, pyPens, pyBrushes);
2142 }
2143 static PyObject *wxDC__DrawPolygonList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2144 return wxPyDrawXXXList(*self, wxPyDrawXXXPolygon, pyCoords, pyPens, pyBrushes);
2145 }
2146 static PyObject *wxDC__DrawTextList(wxDC *self,PyObject *textList,PyObject *pyPoints,PyObject *foregroundList,PyObject *backgroundList){
2147 return wxPyDrawTextList(*self, textList, pyPoints, foregroundList, backgroundList);
2148 }
2149
2150 static void wxDC_GetBoundingBox(wxDC* dc, int* x1, int* y1, int* x2, int* y2) {
2151 *x1 = dc->MinX();
2152 *y1 = dc->MinY();
2153 *x2 = dc->MaxX();
2154 *y2 = dc->MaxY();
2155 }
2156
2157
2158 #include <wx/dcbuffer.h>
2159
2160
2161 #include <wx/dcps.h>
2162
2163
2164 #include <wx/metafile.h>
2165
2166
2167
2168 static void wxColourDatabase_Append(wxColourDatabase *self,wxString const &name,int red,int green,int blue){
2169 self->AddColour(name, wxColour(red, green, blue));
2170 }
2171
2172 #include <wx/effects.h>
2173
2174
2175 #include "wx/renderer.h"
2176
2177
2178 SWIGINTERNSHORT PyObject*
2179 SWIG_From_bool(bool value)
2180 {
2181 PyObject *obj = value ? Py_True : Py_False;
2182 Py_INCREF(obj);
2183 return obj;
2184 }
2185
2186 #ifdef __cplusplus
2187 extern "C" {
2188 #endif
2189 static PyObject *_wrap_new_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2190 PyObject *resultobj;
2191 wxGDIObject *result;
2192 char *kwnames[] = {
2193 NULL
2194 };
2195
2196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GDIObject",kwnames)) goto fail;
2197 {
2198 if (!wxPyCheckForApp()) SWIG_fail;
2199 PyThreadState* __tstate = wxPyBeginAllowThreads();
2200 result = (wxGDIObject *)new wxGDIObject();
2201
2202 wxPyEndAllowThreads(__tstate);
2203 if (PyErr_Occurred()) SWIG_fail;
2204 }
2205 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGDIObject, 1);
2206 return resultobj;
2207 fail:
2208 return NULL;
2209 }
2210
2211
2212 static PyObject *_wrap_delete_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2213 PyObject *resultobj;
2214 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2215 PyObject * obj0 = 0 ;
2216 char *kwnames[] = {
2217 (char *) "self", NULL
2218 };
2219
2220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GDIObject",kwnames,&obj0)) goto fail;
2221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2222 if (SWIG_arg_fail(1)) SWIG_fail;
2223 {
2224 PyThreadState* __tstate = wxPyBeginAllowThreads();
2225 delete arg1;
2226
2227 wxPyEndAllowThreads(__tstate);
2228 if (PyErr_Occurred()) SWIG_fail;
2229 }
2230 Py_INCREF(Py_None); resultobj = Py_None;
2231 return resultobj;
2232 fail:
2233 return NULL;
2234 }
2235
2236
2237 static PyObject *_wrap_GDIObject_GetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2238 PyObject *resultobj;
2239 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2240 bool result;
2241 PyObject * obj0 = 0 ;
2242 char *kwnames[] = {
2243 (char *) "self", NULL
2244 };
2245
2246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_GetVisible",kwnames,&obj0)) goto fail;
2247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2248 if (SWIG_arg_fail(1)) SWIG_fail;
2249 {
2250 PyThreadState* __tstate = wxPyBeginAllowThreads();
2251 result = (bool)(arg1)->GetVisible();
2252
2253 wxPyEndAllowThreads(__tstate);
2254 if (PyErr_Occurred()) SWIG_fail;
2255 }
2256 {
2257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2258 }
2259 return resultobj;
2260 fail:
2261 return NULL;
2262 }
2263
2264
2265 static PyObject *_wrap_GDIObject_SetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2266 PyObject *resultobj;
2267 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2268 bool arg2 ;
2269 PyObject * obj0 = 0 ;
2270 PyObject * obj1 = 0 ;
2271 char *kwnames[] = {
2272 (char *) "self",(char *) "visible", NULL
2273 };
2274
2275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GDIObject_SetVisible",kwnames,&obj0,&obj1)) goto fail;
2276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2277 if (SWIG_arg_fail(1)) SWIG_fail;
2278 {
2279 arg2 = (bool)(SWIG_As_bool(obj1));
2280 if (SWIG_arg_fail(2)) SWIG_fail;
2281 }
2282 {
2283 PyThreadState* __tstate = wxPyBeginAllowThreads();
2284 (arg1)->SetVisible(arg2);
2285
2286 wxPyEndAllowThreads(__tstate);
2287 if (PyErr_Occurred()) SWIG_fail;
2288 }
2289 Py_INCREF(Py_None); resultobj = Py_None;
2290 return resultobj;
2291 fail:
2292 return NULL;
2293 }
2294
2295
2296 static PyObject *_wrap_GDIObject_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
2297 PyObject *resultobj;
2298 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2299 bool result;
2300 PyObject * obj0 = 0 ;
2301 char *kwnames[] = {
2302 (char *) "self", NULL
2303 };
2304
2305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_IsNull",kwnames,&obj0)) goto fail;
2306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2307 if (SWIG_arg_fail(1)) SWIG_fail;
2308 {
2309 PyThreadState* __tstate = wxPyBeginAllowThreads();
2310 result = (bool)(arg1)->IsNull();
2311
2312 wxPyEndAllowThreads(__tstate);
2313 if (PyErr_Occurred()) SWIG_fail;
2314 }
2315 {
2316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2317 }
2318 return resultobj;
2319 fail:
2320 return NULL;
2321 }
2322
2323
2324 static PyObject * GDIObject_swigregister(PyObject *, PyObject *args) {
2325 PyObject *obj;
2326 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2327 SWIG_TypeClientData(SWIGTYPE_p_wxGDIObject, obj);
2328 Py_INCREF(obj);
2329 return Py_BuildValue((char *)"");
2330 }
2331 static PyObject *_wrap_new_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2332 PyObject *resultobj;
2333 byte arg1 = (byte) 0 ;
2334 byte arg2 = (byte) 0 ;
2335 byte arg3 = (byte) 0 ;
2336 wxColour *result;
2337 PyObject * obj0 = 0 ;
2338 PyObject * obj1 = 0 ;
2339 PyObject * obj2 = 0 ;
2340 char *kwnames[] = {
2341 (char *) "red",(char *) "green",(char *) "blue", NULL
2342 };
2343
2344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Colour",kwnames,&obj0,&obj1,&obj2)) goto fail;
2345 if (obj0) {
2346 {
2347 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
2348 if (SWIG_arg_fail(1)) SWIG_fail;
2349 }
2350 }
2351 if (obj1) {
2352 {
2353 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2354 if (SWIG_arg_fail(2)) SWIG_fail;
2355 }
2356 }
2357 if (obj2) {
2358 {
2359 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2360 if (SWIG_arg_fail(3)) SWIG_fail;
2361 }
2362 }
2363 {
2364 PyThreadState* __tstate = wxPyBeginAllowThreads();
2365 result = (wxColour *)new wxColour(arg1,arg2,arg3);
2366
2367 wxPyEndAllowThreads(__tstate);
2368 if (PyErr_Occurred()) SWIG_fail;
2369 }
2370 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2371 return resultobj;
2372 fail:
2373 return NULL;
2374 }
2375
2376
2377 static PyObject *_wrap_new_NamedColour(PyObject *, PyObject *args, PyObject *kwargs) {
2378 PyObject *resultobj;
2379 wxString *arg1 = 0 ;
2380 wxColour *result;
2381 bool temp1 = false ;
2382 PyObject * obj0 = 0 ;
2383 char *kwnames[] = {
2384 (char *) "colorName", NULL
2385 };
2386
2387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_NamedColour",kwnames,&obj0)) goto fail;
2388 {
2389 arg1 = wxString_in_helper(obj0);
2390 if (arg1 == NULL) SWIG_fail;
2391 temp1 = true;
2392 }
2393 {
2394 if (!wxPyCheckForApp()) SWIG_fail;
2395 PyThreadState* __tstate = wxPyBeginAllowThreads();
2396 result = (wxColour *)new wxColour((wxString const &)*arg1);
2397
2398 wxPyEndAllowThreads(__tstate);
2399 if (PyErr_Occurred()) SWIG_fail;
2400 }
2401 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2402 {
2403 if (temp1)
2404 delete arg1;
2405 }
2406 return resultobj;
2407 fail:
2408 {
2409 if (temp1)
2410 delete arg1;
2411 }
2412 return NULL;
2413 }
2414
2415
2416 static PyObject *_wrap_new_ColourRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2417 PyObject *resultobj;
2418 unsigned long arg1 ;
2419 wxColour *result;
2420 PyObject * obj0 = 0 ;
2421 char *kwnames[] = {
2422 (char *) "colRGB", NULL
2423 };
2424
2425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ColourRGB",kwnames,&obj0)) goto fail;
2426 {
2427 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
2428 if (SWIG_arg_fail(1)) SWIG_fail;
2429 }
2430 {
2431 PyThreadState* __tstate = wxPyBeginAllowThreads();
2432 result = (wxColour *)new wxColour(arg1);
2433
2434 wxPyEndAllowThreads(__tstate);
2435 if (PyErr_Occurred()) SWIG_fail;
2436 }
2437 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2438 return resultobj;
2439 fail:
2440 return NULL;
2441 }
2442
2443
2444 static PyObject *_wrap_delete_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2445 PyObject *resultobj;
2446 wxColour *arg1 = (wxColour *) 0 ;
2447 PyObject * obj0 = 0 ;
2448 char *kwnames[] = {
2449 (char *) "self", NULL
2450 };
2451
2452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Colour",kwnames,&obj0)) goto fail;
2453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2454 if (SWIG_arg_fail(1)) SWIG_fail;
2455 {
2456 PyThreadState* __tstate = wxPyBeginAllowThreads();
2457 delete arg1;
2458
2459 wxPyEndAllowThreads(__tstate);
2460 if (PyErr_Occurred()) SWIG_fail;
2461 }
2462 Py_INCREF(Py_None); resultobj = Py_None;
2463 return resultobj;
2464 fail:
2465 return NULL;
2466 }
2467
2468
2469 static PyObject *_wrap_Colour_Red(PyObject *, PyObject *args, PyObject *kwargs) {
2470 PyObject *resultobj;
2471 wxColour *arg1 = (wxColour *) 0 ;
2472 byte result;
2473 PyObject * obj0 = 0 ;
2474 char *kwnames[] = {
2475 (char *) "self", NULL
2476 };
2477
2478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Red",kwnames,&obj0)) goto fail;
2479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2480 if (SWIG_arg_fail(1)) SWIG_fail;
2481 {
2482 PyThreadState* __tstate = wxPyBeginAllowThreads();
2483 result = (byte)(arg1)->Red();
2484
2485 wxPyEndAllowThreads(__tstate);
2486 if (PyErr_Occurred()) SWIG_fail;
2487 }
2488 {
2489 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2490 }
2491 return resultobj;
2492 fail:
2493 return NULL;
2494 }
2495
2496
2497 static PyObject *_wrap_Colour_Green(PyObject *, PyObject *args, PyObject *kwargs) {
2498 PyObject *resultobj;
2499 wxColour *arg1 = (wxColour *) 0 ;
2500 byte result;
2501 PyObject * obj0 = 0 ;
2502 char *kwnames[] = {
2503 (char *) "self", NULL
2504 };
2505
2506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Green",kwnames,&obj0)) goto fail;
2507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2508 if (SWIG_arg_fail(1)) SWIG_fail;
2509 {
2510 PyThreadState* __tstate = wxPyBeginAllowThreads();
2511 result = (byte)(arg1)->Green();
2512
2513 wxPyEndAllowThreads(__tstate);
2514 if (PyErr_Occurred()) SWIG_fail;
2515 }
2516 {
2517 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2518 }
2519 return resultobj;
2520 fail:
2521 return NULL;
2522 }
2523
2524
2525 static PyObject *_wrap_Colour_Blue(PyObject *, PyObject *args, PyObject *kwargs) {
2526 PyObject *resultobj;
2527 wxColour *arg1 = (wxColour *) 0 ;
2528 byte result;
2529 PyObject * obj0 = 0 ;
2530 char *kwnames[] = {
2531 (char *) "self", NULL
2532 };
2533
2534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Blue",kwnames,&obj0)) goto fail;
2535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2536 if (SWIG_arg_fail(1)) SWIG_fail;
2537 {
2538 PyThreadState* __tstate = wxPyBeginAllowThreads();
2539 result = (byte)(arg1)->Blue();
2540
2541 wxPyEndAllowThreads(__tstate);
2542 if (PyErr_Occurred()) SWIG_fail;
2543 }
2544 {
2545 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2546 }
2547 return resultobj;
2548 fail:
2549 return NULL;
2550 }
2551
2552
2553 static PyObject *_wrap_Colour_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
2554 PyObject *resultobj;
2555 wxColour *arg1 = (wxColour *) 0 ;
2556 bool result;
2557 PyObject * obj0 = 0 ;
2558 char *kwnames[] = {
2559 (char *) "self", NULL
2560 };
2561
2562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Ok",kwnames,&obj0)) goto fail;
2563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2564 if (SWIG_arg_fail(1)) SWIG_fail;
2565 {
2566 PyThreadState* __tstate = wxPyBeginAllowThreads();
2567 result = (bool)(arg1)->Ok();
2568
2569 wxPyEndAllowThreads(__tstate);
2570 if (PyErr_Occurred()) SWIG_fail;
2571 }
2572 {
2573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2574 }
2575 return resultobj;
2576 fail:
2577 return NULL;
2578 }
2579
2580
2581 static PyObject *_wrap_Colour_Set(PyObject *, PyObject *args, PyObject *kwargs) {
2582 PyObject *resultobj;
2583 wxColour *arg1 = (wxColour *) 0 ;
2584 byte arg2 ;
2585 byte arg3 ;
2586 byte arg4 ;
2587 PyObject * obj0 = 0 ;
2588 PyObject * obj1 = 0 ;
2589 PyObject * obj2 = 0 ;
2590 PyObject * obj3 = 0 ;
2591 char *kwnames[] = {
2592 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2593 };
2594
2595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Colour_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2597 if (SWIG_arg_fail(1)) SWIG_fail;
2598 {
2599 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2600 if (SWIG_arg_fail(2)) SWIG_fail;
2601 }
2602 {
2603 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2604 if (SWIG_arg_fail(3)) SWIG_fail;
2605 }
2606 {
2607 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2608 if (SWIG_arg_fail(4)) SWIG_fail;
2609 }
2610 {
2611 PyThreadState* __tstate = wxPyBeginAllowThreads();
2612 (arg1)->Set(arg2,arg3,arg4);
2613
2614 wxPyEndAllowThreads(__tstate);
2615 if (PyErr_Occurred()) SWIG_fail;
2616 }
2617 Py_INCREF(Py_None); resultobj = Py_None;
2618 return resultobj;
2619 fail:
2620 return NULL;
2621 }
2622
2623
2624 static PyObject *_wrap_Colour_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2625 PyObject *resultobj;
2626 wxColour *arg1 = (wxColour *) 0 ;
2627 unsigned long arg2 ;
2628 PyObject * obj0 = 0 ;
2629 PyObject * obj1 = 0 ;
2630 char *kwnames[] = {
2631 (char *) "self",(char *) "colRGB", NULL
2632 };
2633
2634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetRGB",kwnames,&obj0,&obj1)) goto fail;
2635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2636 if (SWIG_arg_fail(1)) SWIG_fail;
2637 {
2638 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
2639 if (SWIG_arg_fail(2)) SWIG_fail;
2640 }
2641 {
2642 PyThreadState* __tstate = wxPyBeginAllowThreads();
2643 (arg1)->Set(arg2);
2644
2645 wxPyEndAllowThreads(__tstate);
2646 if (PyErr_Occurred()) SWIG_fail;
2647 }
2648 Py_INCREF(Py_None); resultobj = Py_None;
2649 return resultobj;
2650 fail:
2651 return NULL;
2652 }
2653
2654
2655 static PyObject *_wrap_Colour_SetFromName(PyObject *, PyObject *args, PyObject *kwargs) {
2656 PyObject *resultobj;
2657 wxColour *arg1 = (wxColour *) 0 ;
2658 wxString *arg2 = 0 ;
2659 bool temp2 = false ;
2660 PyObject * obj0 = 0 ;
2661 PyObject * obj1 = 0 ;
2662 char *kwnames[] = {
2663 (char *) "self",(char *) "colourName", NULL
2664 };
2665
2666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetFromName",kwnames,&obj0,&obj1)) goto fail;
2667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2668 if (SWIG_arg_fail(1)) SWIG_fail;
2669 {
2670 arg2 = wxString_in_helper(obj1);
2671 if (arg2 == NULL) SWIG_fail;
2672 temp2 = true;
2673 }
2674 {
2675 PyThreadState* __tstate = wxPyBeginAllowThreads();
2676 (arg1)->InitFromName((wxString const &)*arg2);
2677
2678 wxPyEndAllowThreads(__tstate);
2679 if (PyErr_Occurred()) SWIG_fail;
2680 }
2681 Py_INCREF(Py_None); resultobj = Py_None;
2682 {
2683 if (temp2)
2684 delete arg2;
2685 }
2686 return resultobj;
2687 fail:
2688 {
2689 if (temp2)
2690 delete arg2;
2691 }
2692 return NULL;
2693 }
2694
2695
2696 static PyObject *_wrap_Colour_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2697 PyObject *resultobj;
2698 wxColour *arg1 = (wxColour *) 0 ;
2699 long result;
2700 PyObject * obj0 = 0 ;
2701 char *kwnames[] = {
2702 (char *) "self", NULL
2703 };
2704
2705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetPixel",kwnames,&obj0)) goto fail;
2706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2707 if (SWIG_arg_fail(1)) SWIG_fail;
2708 {
2709 PyThreadState* __tstate = wxPyBeginAllowThreads();
2710 result = (long)((wxColour const *)arg1)->GetPixel();
2711
2712 wxPyEndAllowThreads(__tstate);
2713 if (PyErr_Occurred()) SWIG_fail;
2714 }
2715 {
2716 resultobj = SWIG_From_long((long)(result));
2717 }
2718 return resultobj;
2719 fail:
2720 return NULL;
2721 }
2722
2723
2724 static PyObject *_wrap_Colour___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
2725 PyObject *resultobj;
2726 wxColour *arg1 = (wxColour *) 0 ;
2727 wxColour *arg2 = 0 ;
2728 bool result;
2729 wxColour temp2 ;
2730 PyObject * obj0 = 0 ;
2731 PyObject * obj1 = 0 ;
2732 char *kwnames[] = {
2733 (char *) "self",(char *) "colour", NULL
2734 };
2735
2736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___eq__",kwnames,&obj0,&obj1)) goto fail;
2737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2738 if (SWIG_arg_fail(1)) SWIG_fail;
2739 {
2740 arg2 = &temp2;
2741 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2742 }
2743 {
2744 PyThreadState* __tstate = wxPyBeginAllowThreads();
2745 result = (bool)((wxColour const *)arg1)->operator ==((wxColour const &)*arg2);
2746
2747 wxPyEndAllowThreads(__tstate);
2748 if (PyErr_Occurred()) SWIG_fail;
2749 }
2750 {
2751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2752 }
2753 return resultobj;
2754 fail:
2755 return NULL;
2756 }
2757
2758
2759 static PyObject *_wrap_Colour___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
2760 PyObject *resultobj;
2761 wxColour *arg1 = (wxColour *) 0 ;
2762 wxColour *arg2 = 0 ;
2763 bool result;
2764 wxColour temp2 ;
2765 PyObject * obj0 = 0 ;
2766 PyObject * obj1 = 0 ;
2767 char *kwnames[] = {
2768 (char *) "self",(char *) "colour", NULL
2769 };
2770
2771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___ne__",kwnames,&obj0,&obj1)) goto fail;
2772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2773 if (SWIG_arg_fail(1)) SWIG_fail;
2774 {
2775 arg2 = &temp2;
2776 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2777 }
2778 {
2779 PyThreadState* __tstate = wxPyBeginAllowThreads();
2780 result = (bool)((wxColour const *)arg1)->operator !=((wxColour const &)*arg2);
2781
2782 wxPyEndAllowThreads(__tstate);
2783 if (PyErr_Occurred()) SWIG_fail;
2784 }
2785 {
2786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2787 }
2788 return resultobj;
2789 fail:
2790 return NULL;
2791 }
2792
2793
2794 static PyObject *_wrap_Colour_Get(PyObject *, PyObject *args, PyObject *kwargs) {
2795 PyObject *resultobj;
2796 wxColour *arg1 = (wxColour *) 0 ;
2797 PyObject *result;
2798 PyObject * obj0 = 0 ;
2799 char *kwnames[] = {
2800 (char *) "self", NULL
2801 };
2802
2803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Get",kwnames,&obj0)) goto fail;
2804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2805 if (SWIG_arg_fail(1)) SWIG_fail;
2806 {
2807 PyThreadState* __tstate = wxPyBeginAllowThreads();
2808 result = (PyObject *)wxColour_Get(arg1);
2809
2810 wxPyEndAllowThreads(__tstate);
2811 if (PyErr_Occurred()) SWIG_fail;
2812 }
2813 resultobj = result;
2814 return resultobj;
2815 fail:
2816 return NULL;
2817 }
2818
2819
2820 static PyObject *_wrap_Colour_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2821 PyObject *resultobj;
2822 wxColour *arg1 = (wxColour *) 0 ;
2823 unsigned long result;
2824 PyObject * obj0 = 0 ;
2825 char *kwnames[] = {
2826 (char *) "self", NULL
2827 };
2828
2829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetRGB",kwnames,&obj0)) goto fail;
2830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2831 if (SWIG_arg_fail(1)) SWIG_fail;
2832 {
2833 PyThreadState* __tstate = wxPyBeginAllowThreads();
2834 result = (unsigned long)wxColour_GetRGB(arg1);
2835
2836 wxPyEndAllowThreads(__tstate);
2837 if (PyErr_Occurred()) SWIG_fail;
2838 }
2839 {
2840 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
2841 }
2842 return resultobj;
2843 fail:
2844 return NULL;
2845 }
2846
2847
2848 static PyObject * Colour_swigregister(PyObject *, PyObject *args) {
2849 PyObject *obj;
2850 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2851 SWIG_TypeClientData(SWIGTYPE_p_wxColour, obj);
2852 Py_INCREF(obj);
2853 return Py_BuildValue((char *)"");
2854 }
2855 static PyObject *_wrap_new_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2856 PyObject *resultobj;
2857 int arg1 ;
2858 unsigned char *arg2 = (unsigned char *) 0 ;
2859 unsigned char *arg3 = (unsigned char *) 0 ;
2860 unsigned char *arg4 = (unsigned char *) 0 ;
2861 wxPalette *result;
2862 PyObject * obj0 = 0 ;
2863 PyObject * obj1 = 0 ;
2864 PyObject * obj2 = 0 ;
2865 PyObject * obj3 = 0 ;
2866 char *kwnames[] = {
2867 (char *) "n",(char *) "red",(char *) "green",(char *) "blue", NULL
2868 };
2869
2870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_Palette",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2871 {
2872 arg1 = (int)(SWIG_As_int(obj0));
2873 if (SWIG_arg_fail(1)) SWIG_fail;
2874 }
2875 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2876 if (SWIG_arg_fail(2)) SWIG_fail;
2877 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2878 if (SWIG_arg_fail(3)) SWIG_fail;
2879 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2880 if (SWIG_arg_fail(4)) SWIG_fail;
2881 {
2882 if (!wxPyCheckForApp()) SWIG_fail;
2883 PyThreadState* __tstate = wxPyBeginAllowThreads();
2884 result = (wxPalette *)new wxPalette(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
2885
2886 wxPyEndAllowThreads(__tstate);
2887 if (PyErr_Occurred()) SWIG_fail;
2888 }
2889 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 1);
2890 return resultobj;
2891 fail:
2892 return NULL;
2893 }
2894
2895
2896 static PyObject *_wrap_delete_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2897 PyObject *resultobj;
2898 wxPalette *arg1 = (wxPalette *) 0 ;
2899 PyObject * obj0 = 0 ;
2900 char *kwnames[] = {
2901 (char *) "self", NULL
2902 };
2903
2904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Palette",kwnames,&obj0)) goto fail;
2905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2906 if (SWIG_arg_fail(1)) SWIG_fail;
2907 {
2908 PyThreadState* __tstate = wxPyBeginAllowThreads();
2909 delete arg1;
2910
2911 wxPyEndAllowThreads(__tstate);
2912 if (PyErr_Occurred()) SWIG_fail;
2913 }
2914 Py_INCREF(Py_None); resultobj = Py_None;
2915 return resultobj;
2916 fail:
2917 return NULL;
2918 }
2919
2920
2921 static PyObject *_wrap_Palette_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2922 PyObject *resultobj;
2923 wxPalette *arg1 = (wxPalette *) 0 ;
2924 byte arg2 ;
2925 byte arg3 ;
2926 byte arg4 ;
2927 int result;
2928 PyObject * obj0 = 0 ;
2929 PyObject * obj1 = 0 ;
2930 PyObject * obj2 = 0 ;
2931 PyObject * obj3 = 0 ;
2932 char *kwnames[] = {
2933 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2934 };
2935
2936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Palette_GetPixel",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2938 if (SWIG_arg_fail(1)) SWIG_fail;
2939 {
2940 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2941 if (SWIG_arg_fail(2)) SWIG_fail;
2942 }
2943 {
2944 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2945 if (SWIG_arg_fail(3)) SWIG_fail;
2946 }
2947 {
2948 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2949 if (SWIG_arg_fail(4)) SWIG_fail;
2950 }
2951 {
2952 PyThreadState* __tstate = wxPyBeginAllowThreads();
2953 result = (int)(arg1)->GetPixel(arg2,arg3,arg4);
2954
2955 wxPyEndAllowThreads(__tstate);
2956 if (PyErr_Occurred()) SWIG_fail;
2957 }
2958 {
2959 resultobj = SWIG_From_int((int)(result));
2960 }
2961 return resultobj;
2962 fail:
2963 return NULL;
2964 }
2965
2966
2967 static PyObject *_wrap_Palette_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2968 PyObject *resultobj;
2969 wxPalette *arg1 = (wxPalette *) 0 ;
2970 int arg2 ;
2971 byte *arg3 = (byte *) 0 ;
2972 byte *arg4 = (byte *) 0 ;
2973 byte *arg5 = (byte *) 0 ;
2974 bool result;
2975 byte temp3 ;
2976 int res3 = 0 ;
2977 byte temp4 ;
2978 int res4 = 0 ;
2979 byte temp5 ;
2980 int res5 = 0 ;
2981 PyObject * obj0 = 0 ;
2982 PyObject * obj1 = 0 ;
2983 char *kwnames[] = {
2984 (char *) "self",(char *) "pixel", NULL
2985 };
2986
2987 arg3 = &temp3; res3 = SWIG_NEWOBJ;
2988 arg4 = &temp4; res4 = SWIG_NEWOBJ;
2989 arg5 = &temp5; res5 = SWIG_NEWOBJ;
2990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Palette_GetRGB",kwnames,&obj0,&obj1)) goto fail;
2991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2992 if (SWIG_arg_fail(1)) SWIG_fail;
2993 {
2994 arg2 = (int)(SWIG_As_int(obj1));
2995 if (SWIG_arg_fail(2)) SWIG_fail;
2996 }
2997 {
2998 PyThreadState* __tstate = wxPyBeginAllowThreads();
2999 result = (bool)(arg1)->GetRGB(arg2,arg3,arg4,arg5);
3000
3001 wxPyEndAllowThreads(__tstate);
3002 if (PyErr_Occurred()) SWIG_fail;
3003 }
3004 {
3005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3006 }
3007 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
3008 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
3009 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
3010 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
3011 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
3012 SWIG_From_unsigned_SS_char((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_unsigned_char, 0)));
3013 return resultobj;
3014 fail:
3015 return NULL;
3016 }
3017
3018
3019 static PyObject *_wrap_Palette_GetColoursCount(PyObject *, PyObject *args, PyObject *kwargs) {
3020 PyObject *resultobj;
3021 wxPalette *arg1 = (wxPalette *) 0 ;
3022 int result;
3023 PyObject * obj0 = 0 ;
3024 char *kwnames[] = {
3025 (char *) "self", NULL
3026 };
3027
3028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_GetColoursCount",kwnames,&obj0)) goto fail;
3029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
3030 if (SWIG_arg_fail(1)) SWIG_fail;
3031 {
3032 PyThreadState* __tstate = wxPyBeginAllowThreads();
3033 result = (int)((wxPalette const *)arg1)->GetColoursCount();
3034
3035 wxPyEndAllowThreads(__tstate);
3036 if (PyErr_Occurred()) SWIG_fail;
3037 }
3038 {
3039 resultobj = SWIG_From_int((int)(result));
3040 }
3041 return resultobj;
3042 fail:
3043 return NULL;
3044 }
3045
3046
3047 static PyObject *_wrap_Palette_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3048 PyObject *resultobj;
3049 wxPalette *arg1 = (wxPalette *) 0 ;
3050 bool result;
3051 PyObject * obj0 = 0 ;
3052 char *kwnames[] = {
3053 (char *) "self", NULL
3054 };
3055
3056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_Ok",kwnames,&obj0)) goto fail;
3057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
3058 if (SWIG_arg_fail(1)) SWIG_fail;
3059 {
3060 PyThreadState* __tstate = wxPyBeginAllowThreads();
3061 result = (bool)(arg1)->Ok();
3062
3063 wxPyEndAllowThreads(__tstate);
3064 if (PyErr_Occurred()) SWIG_fail;
3065 }
3066 {
3067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3068 }
3069 return resultobj;
3070 fail:
3071 return NULL;
3072 }
3073
3074
3075 static PyObject * Palette_swigregister(PyObject *, PyObject *args) {
3076 PyObject *obj;
3077 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3078 SWIG_TypeClientData(SWIGTYPE_p_wxPalette, obj);
3079 Py_INCREF(obj);
3080 return Py_BuildValue((char *)"");
3081 }
3082 static PyObject *_wrap_new_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3083 PyObject *resultobj;
3084 wxColour *arg1 = 0 ;
3085 int arg2 = (int) 1 ;
3086 int arg3 = (int) wxSOLID ;
3087 wxPen *result;
3088 wxColour temp1 ;
3089 PyObject * obj0 = 0 ;
3090 PyObject * obj1 = 0 ;
3091 PyObject * obj2 = 0 ;
3092 char *kwnames[] = {
3093 (char *) "colour",(char *) "width",(char *) "style", NULL
3094 };
3095
3096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Pen",kwnames,&obj0,&obj1,&obj2)) goto fail;
3097 {
3098 arg1 = &temp1;
3099 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3100 }
3101 if (obj1) {
3102 {
3103 arg2 = (int)(SWIG_As_int(obj1));
3104 if (SWIG_arg_fail(2)) SWIG_fail;
3105 }
3106 }
3107 if (obj2) {
3108 {
3109 arg3 = (int)(SWIG_As_int(obj2));
3110 if (SWIG_arg_fail(3)) SWIG_fail;
3111 }
3112 }
3113 {
3114 if (!wxPyCheckForApp()) SWIG_fail;
3115 PyThreadState* __tstate = wxPyBeginAllowThreads();
3116 result = (wxPen *)new wxPen(*arg1,arg2,arg3);
3117
3118 wxPyEndAllowThreads(__tstate);
3119 if (PyErr_Occurred()) SWIG_fail;
3120 }
3121 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 1);
3122 return resultobj;
3123 fail:
3124 return NULL;
3125 }
3126
3127
3128 static PyObject *_wrap_delete_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3129 PyObject *resultobj;
3130 wxPen *arg1 = (wxPen *) 0 ;
3131 PyObject * obj0 = 0 ;
3132 char *kwnames[] = {
3133 (char *) "self", NULL
3134 };
3135
3136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Pen",kwnames,&obj0)) goto fail;
3137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3138 if (SWIG_arg_fail(1)) SWIG_fail;
3139 {
3140 PyThreadState* __tstate = wxPyBeginAllowThreads();
3141 delete arg1;
3142
3143 wxPyEndAllowThreads(__tstate);
3144 if (PyErr_Occurred()) SWIG_fail;
3145 }
3146 Py_INCREF(Py_None); resultobj = Py_None;
3147 return resultobj;
3148 fail:
3149 return NULL;
3150 }
3151
3152
3153 static PyObject *_wrap_Pen_GetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3154 PyObject *resultobj;
3155 wxPen *arg1 = (wxPen *) 0 ;
3156 int result;
3157 PyObject * obj0 = 0 ;
3158 char *kwnames[] = {
3159 (char *) "self", NULL
3160 };
3161
3162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetCap",kwnames,&obj0)) goto fail;
3163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3164 if (SWIG_arg_fail(1)) SWIG_fail;
3165 {
3166 PyThreadState* __tstate = wxPyBeginAllowThreads();
3167 result = (int)(arg1)->GetCap();
3168
3169 wxPyEndAllowThreads(__tstate);
3170 if (PyErr_Occurred()) SWIG_fail;
3171 }
3172 {
3173 resultobj = SWIG_From_int((int)(result));
3174 }
3175 return resultobj;
3176 fail:
3177 return NULL;
3178 }
3179
3180
3181 static PyObject *_wrap_Pen_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3182 PyObject *resultobj;
3183 wxPen *arg1 = (wxPen *) 0 ;
3184 wxColour result;
3185 PyObject * obj0 = 0 ;
3186 char *kwnames[] = {
3187 (char *) "self", NULL
3188 };
3189
3190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetColour",kwnames,&obj0)) goto fail;
3191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3192 if (SWIG_arg_fail(1)) SWIG_fail;
3193 {
3194 PyThreadState* __tstate = wxPyBeginAllowThreads();
3195 result = (arg1)->GetColour();
3196
3197 wxPyEndAllowThreads(__tstate);
3198 if (PyErr_Occurred()) SWIG_fail;
3199 }
3200 {
3201 wxColour * resultptr;
3202 resultptr = new wxColour((wxColour &)(result));
3203 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3204 }
3205 return resultobj;
3206 fail:
3207 return NULL;
3208 }
3209
3210
3211 static PyObject *_wrap_Pen_GetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3212 PyObject *resultobj;
3213 wxPen *arg1 = (wxPen *) 0 ;
3214 int result;
3215 PyObject * obj0 = 0 ;
3216 char *kwnames[] = {
3217 (char *) "self", NULL
3218 };
3219
3220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetJoin",kwnames,&obj0)) goto fail;
3221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3222 if (SWIG_arg_fail(1)) SWIG_fail;
3223 {
3224 PyThreadState* __tstate = wxPyBeginAllowThreads();
3225 result = (int)(arg1)->GetJoin();
3226
3227 wxPyEndAllowThreads(__tstate);
3228 if (PyErr_Occurred()) SWIG_fail;
3229 }
3230 {
3231 resultobj = SWIG_From_int((int)(result));
3232 }
3233 return resultobj;
3234 fail:
3235 return NULL;
3236 }
3237
3238
3239 static PyObject *_wrap_Pen_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3240 PyObject *resultobj;
3241 wxPen *arg1 = (wxPen *) 0 ;
3242 int result;
3243 PyObject * obj0 = 0 ;
3244 char *kwnames[] = {
3245 (char *) "self", NULL
3246 };
3247
3248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetStyle",kwnames,&obj0)) goto fail;
3249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3250 if (SWIG_arg_fail(1)) SWIG_fail;
3251 {
3252 PyThreadState* __tstate = wxPyBeginAllowThreads();
3253 result = (int)(arg1)->GetStyle();
3254
3255 wxPyEndAllowThreads(__tstate);
3256 if (PyErr_Occurred()) SWIG_fail;
3257 }
3258 {
3259 resultobj = SWIG_From_int((int)(result));
3260 }
3261 return resultobj;
3262 fail:
3263 return NULL;
3264 }
3265
3266
3267 static PyObject *_wrap_Pen_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3268 PyObject *resultobj;
3269 wxPen *arg1 = (wxPen *) 0 ;
3270 int result;
3271 PyObject * obj0 = 0 ;
3272 char *kwnames[] = {
3273 (char *) "self", NULL
3274 };
3275
3276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetWidth",kwnames,&obj0)) goto fail;
3277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3278 if (SWIG_arg_fail(1)) SWIG_fail;
3279 {
3280 PyThreadState* __tstate = wxPyBeginAllowThreads();
3281 result = (int)(arg1)->GetWidth();
3282
3283 wxPyEndAllowThreads(__tstate);
3284 if (PyErr_Occurred()) SWIG_fail;
3285 }
3286 {
3287 resultobj = SWIG_From_int((int)(result));
3288 }
3289 return resultobj;
3290 fail:
3291 return NULL;
3292 }
3293
3294
3295 static PyObject *_wrap_Pen_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3296 PyObject *resultobj;
3297 wxPen *arg1 = (wxPen *) 0 ;
3298 bool result;
3299 PyObject * obj0 = 0 ;
3300 char *kwnames[] = {
3301 (char *) "self", NULL
3302 };
3303
3304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_Ok",kwnames,&obj0)) goto fail;
3305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3306 if (SWIG_arg_fail(1)) SWIG_fail;
3307 {
3308 PyThreadState* __tstate = wxPyBeginAllowThreads();
3309 result = (bool)(arg1)->Ok();
3310
3311 wxPyEndAllowThreads(__tstate);
3312 if (PyErr_Occurred()) SWIG_fail;
3313 }
3314 {
3315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3316 }
3317 return resultobj;
3318 fail:
3319 return NULL;
3320 }
3321
3322
3323 static PyObject *_wrap_Pen_SetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3324 PyObject *resultobj;
3325 wxPen *arg1 = (wxPen *) 0 ;
3326 int arg2 ;
3327 PyObject * obj0 = 0 ;
3328 PyObject * obj1 = 0 ;
3329 char *kwnames[] = {
3330 (char *) "self",(char *) "cap_style", NULL
3331 };
3332
3333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetCap",kwnames,&obj0,&obj1)) goto fail;
3334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3335 if (SWIG_arg_fail(1)) SWIG_fail;
3336 {
3337 arg2 = (int)(SWIG_As_int(obj1));
3338 if (SWIG_arg_fail(2)) SWIG_fail;
3339 }
3340 {
3341 PyThreadState* __tstate = wxPyBeginAllowThreads();
3342 (arg1)->SetCap(arg2);
3343
3344 wxPyEndAllowThreads(__tstate);
3345 if (PyErr_Occurred()) SWIG_fail;
3346 }
3347 Py_INCREF(Py_None); resultobj = Py_None;
3348 return resultobj;
3349 fail:
3350 return NULL;
3351 }
3352
3353
3354 static PyObject *_wrap_Pen_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3355 PyObject *resultobj;
3356 wxPen *arg1 = (wxPen *) 0 ;
3357 wxColour *arg2 = 0 ;
3358 wxColour temp2 ;
3359 PyObject * obj0 = 0 ;
3360 PyObject * obj1 = 0 ;
3361 char *kwnames[] = {
3362 (char *) "self",(char *) "colour", NULL
3363 };
3364
3365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetColour",kwnames,&obj0,&obj1)) goto fail;
3366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3367 if (SWIG_arg_fail(1)) SWIG_fail;
3368 {
3369 arg2 = &temp2;
3370 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3371 }
3372 {
3373 PyThreadState* __tstate = wxPyBeginAllowThreads();
3374 (arg1)->SetColour(*arg2);
3375
3376 wxPyEndAllowThreads(__tstate);
3377 if (PyErr_Occurred()) SWIG_fail;
3378 }
3379 Py_INCREF(Py_None); resultobj = Py_None;
3380 return resultobj;
3381 fail:
3382 return NULL;
3383 }
3384
3385
3386 static PyObject *_wrap_Pen_SetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3387 PyObject *resultobj;
3388 wxPen *arg1 = (wxPen *) 0 ;
3389 int arg2 ;
3390 PyObject * obj0 = 0 ;
3391 PyObject * obj1 = 0 ;
3392 char *kwnames[] = {
3393 (char *) "self",(char *) "join_style", NULL
3394 };
3395
3396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetJoin",kwnames,&obj0,&obj1)) goto fail;
3397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3398 if (SWIG_arg_fail(1)) SWIG_fail;
3399 {
3400 arg2 = (int)(SWIG_As_int(obj1));
3401 if (SWIG_arg_fail(2)) SWIG_fail;
3402 }
3403 {
3404 PyThreadState* __tstate = wxPyBeginAllowThreads();
3405 (arg1)->SetJoin(arg2);
3406
3407 wxPyEndAllowThreads(__tstate);
3408 if (PyErr_Occurred()) SWIG_fail;
3409 }
3410 Py_INCREF(Py_None); resultobj = Py_None;
3411 return resultobj;
3412 fail:
3413 return NULL;
3414 }
3415
3416
3417 static PyObject *_wrap_Pen_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3418 PyObject *resultobj;
3419 wxPen *arg1 = (wxPen *) 0 ;
3420 int arg2 ;
3421 PyObject * obj0 = 0 ;
3422 PyObject * obj1 = 0 ;
3423 char *kwnames[] = {
3424 (char *) "self",(char *) "style", NULL
3425 };
3426
3427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3429 if (SWIG_arg_fail(1)) SWIG_fail;
3430 {
3431 arg2 = (int)(SWIG_As_int(obj1));
3432 if (SWIG_arg_fail(2)) SWIG_fail;
3433 }
3434 {
3435 PyThreadState* __tstate = wxPyBeginAllowThreads();
3436 (arg1)->SetStyle(arg2);
3437
3438 wxPyEndAllowThreads(__tstate);
3439 if (PyErr_Occurred()) SWIG_fail;
3440 }
3441 Py_INCREF(Py_None); resultobj = Py_None;
3442 return resultobj;
3443 fail:
3444 return NULL;
3445 }
3446
3447
3448 static PyObject *_wrap_Pen_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3449 PyObject *resultobj;
3450 wxPen *arg1 = (wxPen *) 0 ;
3451 int arg2 ;
3452 PyObject * obj0 = 0 ;
3453 PyObject * obj1 = 0 ;
3454 char *kwnames[] = {
3455 (char *) "self",(char *) "width", NULL
3456 };
3457
3458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3460 if (SWIG_arg_fail(1)) SWIG_fail;
3461 {
3462 arg2 = (int)(SWIG_As_int(obj1));
3463 if (SWIG_arg_fail(2)) SWIG_fail;
3464 }
3465 {
3466 PyThreadState* __tstate = wxPyBeginAllowThreads();
3467 (arg1)->SetWidth(arg2);
3468
3469 wxPyEndAllowThreads(__tstate);
3470 if (PyErr_Occurred()) SWIG_fail;
3471 }
3472 Py_INCREF(Py_None); resultobj = Py_None;
3473 return resultobj;
3474 fail:
3475 return NULL;
3476 }
3477
3478
3479 static PyObject *_wrap_Pen_SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3480 PyObject *resultobj;
3481 wxPen *arg1 = (wxPen *) 0 ;
3482 int arg2 ;
3483 wxDash *arg3 = (wxDash *) 0 ;
3484 PyObject * obj0 = 0 ;
3485 PyObject * obj1 = 0 ;
3486 char *kwnames[] = {
3487 (char *) "self",(char *) "dashes", NULL
3488 };
3489
3490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetDashes",kwnames,&obj0,&obj1)) goto fail;
3491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3492 if (SWIG_arg_fail(1)) SWIG_fail;
3493 {
3494 arg2 = PyList_Size(obj1);
3495 arg3 = (wxDash*)byte_LIST_helper(obj1);
3496 if (arg3 == NULL) SWIG_fail;
3497 }
3498 {
3499 PyThreadState* __tstate = wxPyBeginAllowThreads();
3500 (arg1)->SetDashes(arg2,arg3);
3501
3502 wxPyEndAllowThreads(__tstate);
3503 if (PyErr_Occurred()) SWIG_fail;
3504 }
3505 Py_INCREF(Py_None); resultobj = Py_None;
3506 {
3507 if (arg3) delete [] arg3;
3508 }
3509 return resultobj;
3510 fail:
3511 {
3512 if (arg3) delete [] arg3;
3513 }
3514 return NULL;
3515 }
3516
3517
3518 static PyObject *_wrap_Pen_GetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3519 PyObject *resultobj;
3520 wxPen *arg1 = (wxPen *) 0 ;
3521 PyObject *result;
3522 PyObject * obj0 = 0 ;
3523 char *kwnames[] = {
3524 (char *) "self", NULL
3525 };
3526
3527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashes",kwnames,&obj0)) goto fail;
3528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3529 if (SWIG_arg_fail(1)) SWIG_fail;
3530 {
3531 PyThreadState* __tstate = wxPyBeginAllowThreads();
3532 result = (PyObject *)wxPen_GetDashes(arg1);
3533
3534 wxPyEndAllowThreads(__tstate);
3535 if (PyErr_Occurred()) SWIG_fail;
3536 }
3537 resultobj = result;
3538 return resultobj;
3539 fail:
3540 return NULL;
3541 }
3542
3543
3544 static PyObject *_wrap_Pen__SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3545 PyObject *resultobj;
3546 wxPen *arg1 = (wxPen *) 0 ;
3547 PyObject *arg2 = (PyObject *) 0 ;
3548 PyObject *arg3 = (PyObject *) 0 ;
3549 PyObject * obj0 = 0 ;
3550 PyObject * obj1 = 0 ;
3551 PyObject * obj2 = 0 ;
3552 char *kwnames[] = {
3553 (char *) "self",(char *) "_self",(char *) "pyDashes", NULL
3554 };
3555
3556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Pen__SetDashes",kwnames,&obj0,&obj1,&obj2)) goto fail;
3557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3558 if (SWIG_arg_fail(1)) SWIG_fail;
3559 arg2 = obj1;
3560 arg3 = obj2;
3561 {
3562 PyThreadState* __tstate = wxPyBeginAllowThreads();
3563 wxPen__SetDashes(arg1,arg2,arg3);
3564
3565 wxPyEndAllowThreads(__tstate);
3566 if (PyErr_Occurred()) SWIG_fail;
3567 }
3568 Py_INCREF(Py_None); resultobj = Py_None;
3569 return resultobj;
3570 fail:
3571 return NULL;
3572 }
3573
3574
3575 static PyObject *_wrap_Pen___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3576 PyObject *resultobj;
3577 wxPen *arg1 = (wxPen *) 0 ;
3578 wxPen *arg2 = (wxPen *) 0 ;
3579 bool result;
3580 PyObject * obj0 = 0 ;
3581 PyObject * obj1 = 0 ;
3582 char *kwnames[] = {
3583 (char *) "self",(char *) "other", NULL
3584 };
3585
3586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___eq__",kwnames,&obj0,&obj1)) goto fail;
3587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3588 if (SWIG_arg_fail(1)) SWIG_fail;
3589 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3590 if (SWIG_arg_fail(2)) SWIG_fail;
3591 {
3592 PyThreadState* __tstate = wxPyBeginAllowThreads();
3593 result = (bool)wxPen___eq__(arg1,(wxPen const *)arg2);
3594
3595 wxPyEndAllowThreads(__tstate);
3596 if (PyErr_Occurred()) SWIG_fail;
3597 }
3598 {
3599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3600 }
3601 return resultobj;
3602 fail:
3603 return NULL;
3604 }
3605
3606
3607 static PyObject *_wrap_Pen___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3608 PyObject *resultobj;
3609 wxPen *arg1 = (wxPen *) 0 ;
3610 wxPen *arg2 = (wxPen *) 0 ;
3611 bool result;
3612 PyObject * obj0 = 0 ;
3613 PyObject * obj1 = 0 ;
3614 char *kwnames[] = {
3615 (char *) "self",(char *) "other", NULL
3616 };
3617
3618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___ne__",kwnames,&obj0,&obj1)) goto fail;
3619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3620 if (SWIG_arg_fail(1)) SWIG_fail;
3621 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3622 if (SWIG_arg_fail(2)) SWIG_fail;
3623 {
3624 PyThreadState* __tstate = wxPyBeginAllowThreads();
3625 result = (bool)wxPen___ne__(arg1,(wxPen const *)arg2);
3626
3627 wxPyEndAllowThreads(__tstate);
3628 if (PyErr_Occurred()) SWIG_fail;
3629 }
3630 {
3631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3632 }
3633 return resultobj;
3634 fail:
3635 return NULL;
3636 }
3637
3638
3639 static PyObject * Pen_swigregister(PyObject *, PyObject *args) {
3640 PyObject *obj;
3641 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3642 SWIG_TypeClientData(SWIGTYPE_p_wxPen, obj);
3643 Py_INCREF(obj);
3644 return Py_BuildValue((char *)"");
3645 }
3646 static PyObject *_wrap_new_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3647 PyObject *resultobj;
3648 wxColour *arg1 = 0 ;
3649 int arg2 = (int) wxSOLID ;
3650 wxBrush *result;
3651 wxColour temp1 ;
3652 PyObject * obj0 = 0 ;
3653 PyObject * obj1 = 0 ;
3654 char *kwnames[] = {
3655 (char *) "colour",(char *) "style", NULL
3656 };
3657
3658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Brush",kwnames,&obj0,&obj1)) goto fail;
3659 {
3660 arg1 = &temp1;
3661 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3662 }
3663 if (obj1) {
3664 {
3665 arg2 = (int)(SWIG_As_int(obj1));
3666 if (SWIG_arg_fail(2)) SWIG_fail;
3667 }
3668 }
3669 {
3670 if (!wxPyCheckForApp()) SWIG_fail;
3671 PyThreadState* __tstate = wxPyBeginAllowThreads();
3672 result = (wxBrush *)new wxBrush((wxColour const &)*arg1,arg2);
3673
3674 wxPyEndAllowThreads(__tstate);
3675 if (PyErr_Occurred()) SWIG_fail;
3676 }
3677 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 1);
3678 return resultobj;
3679 fail:
3680 return NULL;
3681 }
3682
3683
3684 static PyObject *_wrap_new_BrushFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
3685 PyObject *resultobj;
3686 wxBitmap *arg1 = 0 ;
3687 wxBrush *result;
3688 PyObject * obj0 = 0 ;
3689 char *kwnames[] = {
3690 (char *) "stippleBitmap", NULL
3691 };
3692
3693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BrushFromBitmap",kwnames,&obj0)) goto fail;
3694 {
3695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3696 if (SWIG_arg_fail(1)) SWIG_fail;
3697 if (arg1 == NULL) {
3698 SWIG_null_ref("wxBitmap");
3699 }
3700 if (SWIG_arg_fail(1)) SWIG_fail;
3701 }
3702 {
3703 if (!wxPyCheckForApp()) SWIG_fail;
3704 PyThreadState* __tstate = wxPyBeginAllowThreads();
3705 result = (wxBrush *)new wxBrush((wxBitmap const &)*arg1);
3706
3707 wxPyEndAllowThreads(__tstate);
3708 if (PyErr_Occurred()) SWIG_fail;
3709 }
3710 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 1);
3711 return resultobj;
3712 fail:
3713 return NULL;
3714 }
3715
3716
3717 static PyObject *_wrap_delete_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3718 PyObject *resultobj;
3719 wxBrush *arg1 = (wxBrush *) 0 ;
3720 PyObject * obj0 = 0 ;
3721 char *kwnames[] = {
3722 (char *) "self", NULL
3723 };
3724
3725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Brush",kwnames,&obj0)) goto fail;
3726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3727 if (SWIG_arg_fail(1)) SWIG_fail;
3728 {
3729 PyThreadState* __tstate = wxPyBeginAllowThreads();
3730 delete arg1;
3731
3732 wxPyEndAllowThreads(__tstate);
3733 if (PyErr_Occurred()) SWIG_fail;
3734 }
3735 Py_INCREF(Py_None); resultobj = Py_None;
3736 return resultobj;
3737 fail:
3738 return NULL;
3739 }
3740
3741
3742 static PyObject *_wrap_Brush_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3743 PyObject *resultobj;
3744 wxBrush *arg1 = (wxBrush *) 0 ;
3745 wxColour *arg2 = 0 ;
3746 wxColour temp2 ;
3747 PyObject * obj0 = 0 ;
3748 PyObject * obj1 = 0 ;
3749 char *kwnames[] = {
3750 (char *) "self",(char *) "col", NULL
3751 };
3752
3753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetColour",kwnames,&obj0,&obj1)) goto fail;
3754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3755 if (SWIG_arg_fail(1)) SWIG_fail;
3756 {
3757 arg2 = &temp2;
3758 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3759 }
3760 {
3761 PyThreadState* __tstate = wxPyBeginAllowThreads();
3762 (arg1)->SetColour((wxColour const &)*arg2);
3763
3764 wxPyEndAllowThreads(__tstate);
3765 if (PyErr_Occurred()) SWIG_fail;
3766 }
3767 Py_INCREF(Py_None); resultobj = Py_None;
3768 return resultobj;
3769 fail:
3770 return NULL;
3771 }
3772
3773
3774 static PyObject *_wrap_Brush_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3775 PyObject *resultobj;
3776 wxBrush *arg1 = (wxBrush *) 0 ;
3777 int arg2 ;
3778 PyObject * obj0 = 0 ;
3779 PyObject * obj1 = 0 ;
3780 char *kwnames[] = {
3781 (char *) "self",(char *) "style", NULL
3782 };
3783
3784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3786 if (SWIG_arg_fail(1)) SWIG_fail;
3787 {
3788 arg2 = (int)(SWIG_As_int(obj1));
3789 if (SWIG_arg_fail(2)) SWIG_fail;
3790 }
3791 {
3792 PyThreadState* __tstate = wxPyBeginAllowThreads();
3793 (arg1)->SetStyle(arg2);
3794
3795 wxPyEndAllowThreads(__tstate);
3796 if (PyErr_Occurred()) SWIG_fail;
3797 }
3798 Py_INCREF(Py_None); resultobj = Py_None;
3799 return resultobj;
3800 fail:
3801 return NULL;
3802 }
3803
3804
3805 static PyObject *_wrap_Brush_SetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3806 PyObject *resultobj;
3807 wxBrush *arg1 = (wxBrush *) 0 ;
3808 wxBitmap *arg2 = 0 ;
3809 PyObject * obj0 = 0 ;
3810 PyObject * obj1 = 0 ;
3811 char *kwnames[] = {
3812 (char *) "self",(char *) "stipple", NULL
3813 };
3814
3815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStipple",kwnames,&obj0,&obj1)) goto fail;
3816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3817 if (SWIG_arg_fail(1)) SWIG_fail;
3818 {
3819 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3820 if (SWIG_arg_fail(2)) SWIG_fail;
3821 if (arg2 == NULL) {
3822 SWIG_null_ref("wxBitmap");
3823 }
3824 if (SWIG_arg_fail(2)) SWIG_fail;
3825 }
3826 {
3827 PyThreadState* __tstate = wxPyBeginAllowThreads();
3828 (arg1)->SetStipple((wxBitmap const &)*arg2);
3829
3830 wxPyEndAllowThreads(__tstate);
3831 if (PyErr_Occurred()) SWIG_fail;
3832 }
3833 Py_INCREF(Py_None); resultobj = Py_None;
3834 return resultobj;
3835 fail:
3836 return NULL;
3837 }
3838
3839
3840 static PyObject *_wrap_Brush_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3841 PyObject *resultobj;
3842 wxBrush *arg1 = (wxBrush *) 0 ;
3843 wxColour result;
3844 PyObject * obj0 = 0 ;
3845 char *kwnames[] = {
3846 (char *) "self", NULL
3847 };
3848
3849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetColour",kwnames,&obj0)) goto fail;
3850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3851 if (SWIG_arg_fail(1)) SWIG_fail;
3852 {
3853 PyThreadState* __tstate = wxPyBeginAllowThreads();
3854 result = ((wxBrush const *)arg1)->GetColour();
3855
3856 wxPyEndAllowThreads(__tstate);
3857 if (PyErr_Occurred()) SWIG_fail;
3858 }
3859 {
3860 wxColour * resultptr;
3861 resultptr = new wxColour((wxColour &)(result));
3862 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3863 }
3864 return resultobj;
3865 fail:
3866 return NULL;
3867 }
3868
3869
3870 static PyObject *_wrap_Brush_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3871 PyObject *resultobj;
3872 wxBrush *arg1 = (wxBrush *) 0 ;
3873 int result;
3874 PyObject * obj0 = 0 ;
3875 char *kwnames[] = {
3876 (char *) "self", NULL
3877 };
3878
3879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStyle",kwnames,&obj0)) goto fail;
3880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3881 if (SWIG_arg_fail(1)) SWIG_fail;
3882 {
3883 PyThreadState* __tstate = wxPyBeginAllowThreads();
3884 result = (int)((wxBrush const *)arg1)->GetStyle();
3885
3886 wxPyEndAllowThreads(__tstate);
3887 if (PyErr_Occurred()) SWIG_fail;
3888 }
3889 {
3890 resultobj = SWIG_From_int((int)(result));
3891 }
3892 return resultobj;
3893 fail:
3894 return NULL;
3895 }
3896
3897
3898 static PyObject *_wrap_Brush_GetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3899 PyObject *resultobj;
3900 wxBrush *arg1 = (wxBrush *) 0 ;
3901 wxBitmap *result;
3902 PyObject * obj0 = 0 ;
3903 char *kwnames[] = {
3904 (char *) "self", NULL
3905 };
3906
3907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStipple",kwnames,&obj0)) goto fail;
3908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3909 if (SWIG_arg_fail(1)) SWIG_fail;
3910 {
3911 PyThreadState* __tstate = wxPyBeginAllowThreads();
3912 result = (wxBitmap *)((wxBrush const *)arg1)->GetStipple();
3913
3914 wxPyEndAllowThreads(__tstate);
3915 if (PyErr_Occurred()) SWIG_fail;
3916 }
3917 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 0);
3918 return resultobj;
3919 fail:
3920 return NULL;
3921 }
3922
3923
3924 static PyObject *_wrap_Brush_IsHatch(PyObject *, PyObject *args, PyObject *kwargs) {
3925 PyObject *resultobj;
3926 wxBrush *arg1 = (wxBrush *) 0 ;
3927 bool result;
3928 PyObject * obj0 = 0 ;
3929 char *kwnames[] = {
3930 (char *) "self", NULL
3931 };
3932
3933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_IsHatch",kwnames,&obj0)) goto fail;
3934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3935 if (SWIG_arg_fail(1)) SWIG_fail;
3936 {
3937 PyThreadState* __tstate = wxPyBeginAllowThreads();
3938 result = (bool)((wxBrush const *)arg1)->IsHatch();
3939
3940 wxPyEndAllowThreads(__tstate);
3941 if (PyErr_Occurred()) SWIG_fail;
3942 }
3943 {
3944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3945 }
3946 return resultobj;
3947 fail:
3948 return NULL;
3949 }
3950
3951
3952 static PyObject *_wrap_Brush_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3953 PyObject *resultobj;
3954 wxBrush *arg1 = (wxBrush *) 0 ;
3955 bool result;
3956 PyObject * obj0 = 0 ;
3957 char *kwnames[] = {
3958 (char *) "self", NULL
3959 };
3960
3961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_Ok",kwnames,&obj0)) goto fail;
3962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3963 if (SWIG_arg_fail(1)) SWIG_fail;
3964 {
3965 PyThreadState* __tstate = wxPyBeginAllowThreads();
3966 result = (bool)(arg1)->Ok();
3967
3968 wxPyEndAllowThreads(__tstate);
3969 if (PyErr_Occurred()) SWIG_fail;
3970 }
3971 {
3972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3973 }
3974 return resultobj;
3975 fail:
3976 return NULL;
3977 }
3978
3979
3980 static PyObject *_wrap_Brush_MacGetTheme(PyObject *, PyObject *args, PyObject *kwargs) {
3981 PyObject *resultobj;
3982 wxBrush *arg1 = (wxBrush *) 0 ;
3983 short result;
3984 PyObject * obj0 = 0 ;
3985 char *kwnames[] = {
3986 (char *) "self", NULL
3987 };
3988
3989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_MacGetTheme",kwnames,&obj0)) goto fail;
3990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3991 if (SWIG_arg_fail(1)) SWIG_fail;
3992 {
3993 PyThreadState* __tstate = wxPyBeginAllowThreads();
3994 result = (short)(arg1)->MacGetTheme();
3995
3996 wxPyEndAllowThreads(__tstate);
3997 if (PyErr_Occurred()) SWIG_fail;
3998 }
3999 {
4000 resultobj = SWIG_From_short((short)(result));
4001 }
4002 return resultobj;
4003 fail:
4004 return NULL;
4005 }
4006
4007
4008 static PyObject *_wrap_Brush_MacSetTheme(PyObject *, PyObject *args, PyObject *kwargs) {
4009 PyObject *resultobj;
4010 wxBrush *arg1 = (wxBrush *) 0 ;
4011 short arg2 ;
4012 PyObject * obj0 = 0 ;
4013 PyObject * obj1 = 0 ;
4014 char *kwnames[] = {
4015 (char *) "self",(char *) "macThemeBrush", NULL
4016 };
4017
4018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_MacSetTheme",kwnames,&obj0,&obj1)) goto fail;
4019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
4020 if (SWIG_arg_fail(1)) SWIG_fail;
4021 {
4022 arg2 = (short)(SWIG_As_short(obj1));
4023 if (SWIG_arg_fail(2)) SWIG_fail;
4024 }
4025 {
4026 PyThreadState* __tstate = wxPyBeginAllowThreads();
4027 (arg1)->MacSetTheme(arg2);
4028
4029 wxPyEndAllowThreads(__tstate);
4030 if (PyErr_Occurred()) SWIG_fail;
4031 }
4032 Py_INCREF(Py_None); resultobj = Py_None;
4033 return resultobj;
4034 fail:
4035 return NULL;
4036 }
4037
4038
4039 static PyObject * Brush_swigregister(PyObject *, PyObject *args) {
4040 PyObject *obj;
4041 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4042 SWIG_TypeClientData(SWIGTYPE_p_wxBrush, obj);
4043 Py_INCREF(obj);
4044 return Py_BuildValue((char *)"");
4045 }
4046 static PyObject *_wrap_new_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4047 PyObject *resultobj;
4048 wxString *arg1 = 0 ;
4049 wxBitmapType arg2 = (wxBitmapType) wxBITMAP_TYPE_ANY ;
4050 wxBitmap *result;
4051 bool temp1 = false ;
4052 PyObject * obj0 = 0 ;
4053 PyObject * obj1 = 0 ;
4054 char *kwnames[] = {
4055 (char *) "name",(char *) "type", NULL
4056 };
4057
4058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Bitmap",kwnames,&obj0,&obj1)) goto fail;
4059 {
4060 arg1 = wxString_in_helper(obj0);
4061 if (arg1 == NULL) SWIG_fail;
4062 temp1 = true;
4063 }
4064 if (obj1) {
4065 {
4066 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
4067 if (SWIG_arg_fail(2)) SWIG_fail;
4068 }
4069 }
4070 {
4071 if (!wxPyCheckForApp()) SWIG_fail;
4072 PyThreadState* __tstate = wxPyBeginAllowThreads();
4073 result = (wxBitmap *)new wxBitmap((wxString const &)*arg1,(wxBitmapType )arg2);
4074
4075 wxPyEndAllowThreads(__tstate);
4076 if (PyErr_Occurred()) SWIG_fail;
4077 }
4078 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4079 {
4080 if (temp1)
4081 delete arg1;
4082 }
4083 return resultobj;
4084 fail:
4085 {
4086 if (temp1)
4087 delete arg1;
4088 }
4089 return NULL;
4090 }
4091
4092
4093 static PyObject *_wrap_delete_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4094 PyObject *resultobj;
4095 wxBitmap *arg1 = (wxBitmap *) 0 ;
4096 PyObject * obj0 = 0 ;
4097 char *kwnames[] = {
4098 (char *) "self", NULL
4099 };
4100
4101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Bitmap",kwnames,&obj0)) goto fail;
4102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4103 if (SWIG_arg_fail(1)) SWIG_fail;
4104 {
4105 PyThreadState* __tstate = wxPyBeginAllowThreads();
4106 delete arg1;
4107
4108 wxPyEndAllowThreads(__tstate);
4109 if (PyErr_Occurred()) SWIG_fail;
4110 }
4111 Py_INCREF(Py_None); resultobj = Py_None;
4112 return resultobj;
4113 fail:
4114 return NULL;
4115 }
4116
4117
4118 static PyObject *_wrap_new_EmptyBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4119 PyObject *resultobj;
4120 int arg1 ;
4121 int arg2 ;
4122 int arg3 = (int) -1 ;
4123 wxBitmap *result;
4124 PyObject * obj0 = 0 ;
4125 PyObject * obj1 = 0 ;
4126 PyObject * obj2 = 0 ;
4127 char *kwnames[] = {
4128 (char *) "width",(char *) "height",(char *) "depth", NULL
4129 };
4130
4131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_EmptyBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
4132 {
4133 arg1 = (int)(SWIG_As_int(obj0));
4134 if (SWIG_arg_fail(1)) SWIG_fail;
4135 }
4136 {
4137 arg2 = (int)(SWIG_As_int(obj1));
4138 if (SWIG_arg_fail(2)) SWIG_fail;
4139 }
4140 if (obj2) {
4141 {
4142 arg3 = (int)(SWIG_As_int(obj2));
4143 if (SWIG_arg_fail(3)) SWIG_fail;
4144 }
4145 }
4146 {
4147 if (!wxPyCheckForApp()) SWIG_fail;
4148 PyThreadState* __tstate = wxPyBeginAllowThreads();
4149 result = (wxBitmap *)new wxBitmap(arg1,arg2,arg3);
4150
4151 wxPyEndAllowThreads(__tstate);
4152 if (PyErr_Occurred()) SWIG_fail;
4153 }
4154 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4155 return resultobj;
4156 fail:
4157 return NULL;
4158 }
4159
4160
4161 static PyObject *_wrap_new_BitmapFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4162 PyObject *resultobj;
4163 wxIcon *arg1 = 0 ;
4164 wxBitmap *result;
4165 PyObject * obj0 = 0 ;
4166 char *kwnames[] = {
4167 (char *) "icon", NULL
4168 };
4169
4170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromIcon",kwnames,&obj0)) goto fail;
4171 {
4172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4173 if (SWIG_arg_fail(1)) SWIG_fail;
4174 if (arg1 == NULL) {
4175 SWIG_null_ref("wxIcon");
4176 }
4177 if (SWIG_arg_fail(1)) SWIG_fail;
4178 }
4179 {
4180 if (!wxPyCheckForApp()) SWIG_fail;
4181 PyThreadState* __tstate = wxPyBeginAllowThreads();
4182 result = (wxBitmap *)new wxBitmap((wxIcon const &)*arg1);
4183
4184 wxPyEndAllowThreads(__tstate);
4185 if (PyErr_Occurred()) SWIG_fail;
4186 }
4187 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4188 return resultobj;
4189 fail:
4190 return NULL;
4191 }
4192
4193
4194 static PyObject *_wrap_new_BitmapFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
4195 PyObject *resultobj;
4196 wxImage *arg1 = 0 ;
4197 int arg2 = (int) -1 ;
4198 wxBitmap *result;
4199 PyObject * obj0 = 0 ;
4200 PyObject * obj1 = 0 ;
4201 char *kwnames[] = {
4202 (char *) "image",(char *) "depth", NULL
4203 };
4204
4205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BitmapFromImage",kwnames,&obj0,&obj1)) goto fail;
4206 {
4207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
4208 if (SWIG_arg_fail(1)) SWIG_fail;
4209 if (arg1 == NULL) {
4210 SWIG_null_ref("wxImage");
4211 }
4212 if (SWIG_arg_fail(1)) SWIG_fail;
4213 }
4214 if (obj1) {
4215 {
4216 arg2 = (int)(SWIG_As_int(obj1));
4217 if (SWIG_arg_fail(2)) SWIG_fail;
4218 }
4219 }
4220 {
4221 if (!wxPyCheckForApp()) SWIG_fail;
4222 PyThreadState* __tstate = wxPyBeginAllowThreads();
4223 result = (wxBitmap *)new wxBitmap((wxImage const &)*arg1,arg2);
4224
4225 wxPyEndAllowThreads(__tstate);
4226 if (PyErr_Occurred()) SWIG_fail;
4227 }
4228 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4229 return resultobj;
4230 fail:
4231 return NULL;
4232 }
4233
4234
4235 static PyObject *_wrap_new_BitmapFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
4236 PyObject *resultobj;
4237 PyObject *arg1 = (PyObject *) 0 ;
4238 wxBitmap *result;
4239 PyObject * obj0 = 0 ;
4240 char *kwnames[] = {
4241 (char *) "listOfStrings", NULL
4242 };
4243
4244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromXPMData",kwnames,&obj0)) goto fail;
4245 arg1 = obj0;
4246 {
4247 if (!wxPyCheckForApp()) SWIG_fail;
4248 PyThreadState* __tstate = wxPyBeginAllowThreads();
4249 result = (wxBitmap *)new_wxBitmap(arg1);
4250
4251 wxPyEndAllowThreads(__tstate);
4252 if (PyErr_Occurred()) SWIG_fail;
4253 }
4254 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4255 return resultobj;
4256 fail:
4257 return NULL;
4258 }
4259
4260
4261 static PyObject *_wrap_new_BitmapFromBits(PyObject *, PyObject *args, PyObject *kwargs) {
4262 PyObject *resultobj;
4263 PyObject *arg1 = (PyObject *) 0 ;
4264 int arg2 ;
4265 int arg3 ;
4266 int arg4 = (int) 1 ;
4267 wxBitmap *result;
4268 PyObject * obj0 = 0 ;
4269 PyObject * obj1 = 0 ;
4270 PyObject * obj2 = 0 ;
4271 PyObject * obj3 = 0 ;
4272 char *kwnames[] = {
4273 (char *) "bits",(char *) "width",(char *) "height",(char *) "depth", NULL
4274 };
4275
4276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:new_BitmapFromBits",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4277 arg1 = obj0;
4278 {
4279 arg2 = (int)(SWIG_As_int(obj1));
4280 if (SWIG_arg_fail(2)) SWIG_fail;
4281 }
4282 {
4283 arg3 = (int)(SWIG_As_int(obj2));
4284 if (SWIG_arg_fail(3)) SWIG_fail;
4285 }
4286 if (obj3) {
4287 {
4288 arg4 = (int)(SWIG_As_int(obj3));
4289 if (SWIG_arg_fail(4)) SWIG_fail;
4290 }
4291 }
4292 {
4293 if (!wxPyCheckForApp()) SWIG_fail;
4294 PyThreadState* __tstate = wxPyBeginAllowThreads();
4295 result = (wxBitmap *)new_wxBitmap(arg1,arg2,arg3,arg4);
4296
4297 wxPyEndAllowThreads(__tstate);
4298 if (PyErr_Occurred()) SWIG_fail;
4299 }
4300 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4301 return resultobj;
4302 fail:
4303 return NULL;
4304 }
4305
4306
4307 static PyObject *_wrap_Bitmap_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
4308 PyObject *resultobj;
4309 wxBitmap *arg1 = (wxBitmap *) 0 ;
4310 bool result;
4311 PyObject * obj0 = 0 ;
4312 char *kwnames[] = {
4313 (char *) "self", NULL
4314 };
4315
4316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_Ok",kwnames,&obj0)) goto fail;
4317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4318 if (SWIG_arg_fail(1)) SWIG_fail;
4319 {
4320 PyThreadState* __tstate = wxPyBeginAllowThreads();
4321 result = (bool)(arg1)->Ok();
4322
4323 wxPyEndAllowThreads(__tstate);
4324 if (PyErr_Occurred()) SWIG_fail;
4325 }
4326 {
4327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4328 }
4329 return resultobj;
4330 fail:
4331 return NULL;
4332 }
4333
4334
4335 static PyObject *_wrap_Bitmap_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4336 PyObject *resultobj;
4337 wxBitmap *arg1 = (wxBitmap *) 0 ;
4338 int result;
4339 PyObject * obj0 = 0 ;
4340 char *kwnames[] = {
4341 (char *) "self", NULL
4342 };
4343
4344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetWidth",kwnames,&obj0)) goto fail;
4345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4346 if (SWIG_arg_fail(1)) SWIG_fail;
4347 {
4348 PyThreadState* __tstate = wxPyBeginAllowThreads();
4349 result = (int)(arg1)->GetWidth();
4350
4351 wxPyEndAllowThreads(__tstate);
4352 if (PyErr_Occurred()) SWIG_fail;
4353 }
4354 {
4355 resultobj = SWIG_From_int((int)(result));
4356 }
4357 return resultobj;
4358 fail:
4359 return NULL;
4360 }
4361
4362
4363 static PyObject *_wrap_Bitmap_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4364 PyObject *resultobj;
4365 wxBitmap *arg1 = (wxBitmap *) 0 ;
4366 int result;
4367 PyObject * obj0 = 0 ;
4368 char *kwnames[] = {
4369 (char *) "self", NULL
4370 };
4371
4372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetHeight",kwnames,&obj0)) goto fail;
4373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4374 if (SWIG_arg_fail(1)) SWIG_fail;
4375 {
4376 PyThreadState* __tstate = wxPyBeginAllowThreads();
4377 result = (int)(arg1)->GetHeight();
4378
4379 wxPyEndAllowThreads(__tstate);
4380 if (PyErr_Occurred()) SWIG_fail;
4381 }
4382 {
4383 resultobj = SWIG_From_int((int)(result));
4384 }
4385 return resultobj;
4386 fail:
4387 return NULL;
4388 }
4389
4390
4391 static PyObject *_wrap_Bitmap_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4392 PyObject *resultobj;
4393 wxBitmap *arg1 = (wxBitmap *) 0 ;
4394 int result;
4395 PyObject * obj0 = 0 ;
4396 char *kwnames[] = {
4397 (char *) "self", NULL
4398 };
4399
4400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetDepth",kwnames,&obj0)) goto fail;
4401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4402 if (SWIG_arg_fail(1)) SWIG_fail;
4403 {
4404 PyThreadState* __tstate = wxPyBeginAllowThreads();
4405 result = (int)(arg1)->GetDepth();
4406
4407 wxPyEndAllowThreads(__tstate);
4408 if (PyErr_Occurred()) SWIG_fail;
4409 }
4410 {
4411 resultobj = SWIG_From_int((int)(result));
4412 }
4413 return resultobj;
4414 fail:
4415 return NULL;
4416 }
4417
4418
4419 static PyObject *_wrap_Bitmap_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4420 PyObject *resultobj;
4421 wxBitmap *arg1 = (wxBitmap *) 0 ;
4422 wxSize result;
4423 PyObject * obj0 = 0 ;
4424 char *kwnames[] = {
4425 (char *) "self", NULL
4426 };
4427
4428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetSize",kwnames,&obj0)) goto fail;
4429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4430 if (SWIG_arg_fail(1)) SWIG_fail;
4431 {
4432 PyThreadState* __tstate = wxPyBeginAllowThreads();
4433 result = wxBitmap_GetSize(arg1);
4434
4435 wxPyEndAllowThreads(__tstate);
4436 if (PyErr_Occurred()) SWIG_fail;
4437 }
4438 {
4439 wxSize * resultptr;
4440 resultptr = new wxSize((wxSize &)(result));
4441 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
4442 }
4443 return resultobj;
4444 fail:
4445 return NULL;
4446 }
4447
4448
4449 static PyObject *_wrap_Bitmap_ConvertToImage(PyObject *, PyObject *args, PyObject *kwargs) {
4450 PyObject *resultobj;
4451 wxBitmap *arg1 = (wxBitmap *) 0 ;
4452 SwigValueWrapper<wxImage > result;
4453 PyObject * obj0 = 0 ;
4454 char *kwnames[] = {
4455 (char *) "self", NULL
4456 };
4457
4458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_ConvertToImage",kwnames,&obj0)) goto fail;
4459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4460 if (SWIG_arg_fail(1)) SWIG_fail;
4461 {
4462 PyThreadState* __tstate = wxPyBeginAllowThreads();
4463 result = ((wxBitmap const *)arg1)->ConvertToImage();
4464
4465 wxPyEndAllowThreads(__tstate);
4466 if (PyErr_Occurred()) SWIG_fail;
4467 }
4468 {
4469 wxImage * resultptr;
4470 resultptr = new wxImage((wxImage &)(result));
4471 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
4472 }
4473 return resultobj;
4474 fail:
4475 return NULL;
4476 }
4477
4478
4479 static PyObject *_wrap_Bitmap_GetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4480 PyObject *resultobj;
4481 wxBitmap *arg1 = (wxBitmap *) 0 ;
4482 wxMask *result;
4483 PyObject * obj0 = 0 ;
4484 char *kwnames[] = {
4485 (char *) "self", NULL
4486 };
4487
4488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetMask",kwnames,&obj0)) goto fail;
4489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4490 if (SWIG_arg_fail(1)) SWIG_fail;
4491 {
4492 PyThreadState* __tstate = wxPyBeginAllowThreads();
4493 result = (wxMask *)((wxBitmap const *)arg1)->GetMask();
4494
4495 wxPyEndAllowThreads(__tstate);
4496 if (PyErr_Occurred()) SWIG_fail;
4497 }
4498 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 0);
4499 return resultobj;
4500 fail:
4501 return NULL;
4502 }
4503
4504
4505 static PyObject *_wrap_Bitmap_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4506 PyObject *resultobj;
4507 wxBitmap *arg1 = (wxBitmap *) 0 ;
4508 wxMask *arg2 = (wxMask *) 0 ;
4509 PyObject * obj0 = 0 ;
4510 PyObject * obj1 = 0 ;
4511 char *kwnames[] = {
4512 (char *) "self",(char *) "mask", NULL
4513 };
4514
4515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMask",kwnames,&obj0,&obj1)) goto fail;
4516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4517 if (SWIG_arg_fail(1)) SWIG_fail;
4518 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMask, SWIG_POINTER_EXCEPTION | 0);
4519 if (SWIG_arg_fail(2)) SWIG_fail;
4520 {
4521 PyThreadState* __tstate = wxPyBeginAllowThreads();
4522 (arg1)->SetMask(arg2);
4523
4524 wxPyEndAllowThreads(__tstate);
4525 if (PyErr_Occurred()) SWIG_fail;
4526 }
4527 Py_INCREF(Py_None); resultobj = Py_None;
4528 return resultobj;
4529 fail:
4530 return NULL;
4531 }
4532
4533
4534 static PyObject *_wrap_Bitmap_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
4535 PyObject *resultobj;
4536 wxBitmap *arg1 = (wxBitmap *) 0 ;
4537 wxColour *arg2 = 0 ;
4538 wxColour temp2 ;
4539 PyObject * obj0 = 0 ;
4540 PyObject * obj1 = 0 ;
4541 char *kwnames[] = {
4542 (char *) "self",(char *) "colour", NULL
4543 };
4544
4545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMaskColour",kwnames,&obj0,&obj1)) goto fail;
4546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4547 if (SWIG_arg_fail(1)) SWIG_fail;
4548 {
4549 arg2 = &temp2;
4550 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4551 }
4552 {
4553 PyThreadState* __tstate = wxPyBeginAllowThreads();
4554 wxBitmap_SetMaskColour(arg1,(wxColour const &)*arg2);
4555
4556 wxPyEndAllowThreads(__tstate);
4557 if (PyErr_Occurred()) SWIG_fail;
4558 }
4559 Py_INCREF(Py_None); resultobj = Py_None;
4560 return resultobj;
4561 fail:
4562 return NULL;
4563 }
4564
4565
4566 static PyObject *_wrap_Bitmap_GetSubBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4567 PyObject *resultobj;
4568 wxBitmap *arg1 = (wxBitmap *) 0 ;
4569 wxRect *arg2 = 0 ;
4570 SwigValueWrapper<wxBitmap > result;
4571 wxRect temp2 ;
4572 PyObject * obj0 = 0 ;
4573 PyObject * obj1 = 0 ;
4574 char *kwnames[] = {
4575 (char *) "self",(char *) "rect", NULL
4576 };
4577
4578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_GetSubBitmap",kwnames,&obj0,&obj1)) goto fail;
4579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4580 if (SWIG_arg_fail(1)) SWIG_fail;
4581 {
4582 arg2 = &temp2;
4583 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4584 }
4585 {
4586 PyThreadState* __tstate = wxPyBeginAllowThreads();
4587 result = ((wxBitmap const *)arg1)->GetSubBitmap((wxRect const &)*arg2);
4588
4589 wxPyEndAllowThreads(__tstate);
4590 if (PyErr_Occurred()) SWIG_fail;
4591 }
4592 {
4593 wxBitmap * resultptr;
4594 resultptr = new wxBitmap((wxBitmap &)(result));
4595 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
4596 }
4597 return resultobj;
4598 fail:
4599 return NULL;
4600 }
4601
4602
4603 static PyObject *_wrap_Bitmap_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
4604 PyObject *resultobj;
4605 wxBitmap *arg1 = (wxBitmap *) 0 ;
4606 wxString *arg2 = 0 ;
4607 wxBitmapType arg3 ;
4608 wxPalette *arg4 = (wxPalette *) NULL ;
4609 bool result;
4610 bool temp2 = false ;
4611 PyObject * obj0 = 0 ;
4612 PyObject * obj1 = 0 ;
4613 PyObject * obj2 = 0 ;
4614 PyObject * obj3 = 0 ;
4615 char *kwnames[] = {
4616 (char *) "self",(char *) "name",(char *) "type",(char *) "palette", NULL
4617 };
4618
4619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Bitmap_SaveFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4621 if (SWIG_arg_fail(1)) SWIG_fail;
4622 {
4623 arg2 = wxString_in_helper(obj1);
4624 if (arg2 == NULL) SWIG_fail;
4625 temp2 = true;
4626 }
4627 {
4628 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4629 if (SWIG_arg_fail(3)) SWIG_fail;
4630 }
4631 if (obj3) {
4632 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
4633 if (SWIG_arg_fail(4)) SWIG_fail;
4634 }
4635 {
4636 PyThreadState* __tstate = wxPyBeginAllowThreads();
4637 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxBitmapType )arg3,arg4);
4638
4639 wxPyEndAllowThreads(__tstate);
4640 if (PyErr_Occurred()) SWIG_fail;
4641 }
4642 {
4643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4644 }
4645 {
4646 if (temp2)
4647 delete arg2;
4648 }
4649 return resultobj;
4650 fail:
4651 {
4652 if (temp2)
4653 delete arg2;
4654 }
4655 return NULL;
4656 }
4657
4658
4659 static PyObject *_wrap_Bitmap_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
4660 PyObject *resultobj;
4661 wxBitmap *arg1 = (wxBitmap *) 0 ;
4662 wxString *arg2 = 0 ;
4663 wxBitmapType arg3 ;
4664 bool result;
4665 bool temp2 = false ;
4666 PyObject * obj0 = 0 ;
4667 PyObject * obj1 = 0 ;
4668 PyObject * obj2 = 0 ;
4669 char *kwnames[] = {
4670 (char *) "self",(char *) "name",(char *) "type", NULL
4671 };
4672
4673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Bitmap_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
4674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4675 if (SWIG_arg_fail(1)) SWIG_fail;
4676 {
4677 arg2 = wxString_in_helper(obj1);
4678 if (arg2 == NULL) SWIG_fail;
4679 temp2 = true;
4680 }
4681 {
4682 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4683 if (SWIG_arg_fail(3)) SWIG_fail;
4684 }
4685 {
4686 PyThreadState* __tstate = wxPyBeginAllowThreads();
4687 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
4688
4689 wxPyEndAllowThreads(__tstate);
4690 if (PyErr_Occurred()) SWIG_fail;
4691 }
4692 {
4693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4694 }
4695 {
4696 if (temp2)
4697 delete arg2;
4698 }
4699 return resultobj;
4700 fail:
4701 {
4702 if (temp2)
4703 delete arg2;
4704 }
4705 return NULL;
4706 }
4707
4708
4709 static PyObject *_wrap_Bitmap_GetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
4710 PyObject *resultobj;
4711 wxBitmap *arg1 = (wxBitmap *) 0 ;
4712 wxPalette *result;
4713 PyObject * obj0 = 0 ;
4714 char *kwnames[] = {
4715 (char *) "self", NULL
4716 };
4717
4718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetPalette",kwnames,&obj0)) goto fail;
4719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4720 if (SWIG_arg_fail(1)) SWIG_fail;
4721 {
4722 PyThreadState* __tstate = wxPyBeginAllowThreads();
4723 result = (wxPalette *)((wxBitmap const *)arg1)->GetPalette();
4724
4725 wxPyEndAllowThreads(__tstate);
4726 if (PyErr_Occurred()) SWIG_fail;
4727 }
4728 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 0);
4729 return resultobj;
4730 fail:
4731 return NULL;
4732 }
4733
4734
4735 static PyObject *_wrap_Bitmap_CopyFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4736 PyObject *resultobj;
4737 wxBitmap *arg1 = (wxBitmap *) 0 ;
4738 wxIcon *arg2 = 0 ;
4739 bool result;
4740 PyObject * obj0 = 0 ;
4741 PyObject * obj1 = 0 ;
4742 char *kwnames[] = {
4743 (char *) "self",(char *) "icon", NULL
4744 };
4745
4746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromIcon",kwnames,&obj0,&obj1)) goto fail;
4747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4748 if (SWIG_arg_fail(1)) SWIG_fail;
4749 {
4750 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4751 if (SWIG_arg_fail(2)) SWIG_fail;
4752 if (arg2 == NULL) {
4753 SWIG_null_ref("wxIcon");
4754 }
4755 if (SWIG_arg_fail(2)) SWIG_fail;
4756 }
4757 {
4758 PyThreadState* __tstate = wxPyBeginAllowThreads();
4759 result = (bool)(arg1)->CopyFromIcon((wxIcon const &)*arg2);
4760
4761 wxPyEndAllowThreads(__tstate);
4762 if (PyErr_Occurred()) SWIG_fail;
4763 }
4764 {
4765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4766 }
4767 return resultobj;
4768 fail:
4769 return NULL;
4770 }
4771
4772
4773 static PyObject *_wrap_Bitmap_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4774 PyObject *resultobj;
4775 wxBitmap *arg1 = (wxBitmap *) 0 ;
4776 int arg2 ;
4777 PyObject * obj0 = 0 ;
4778 PyObject * obj1 = 0 ;
4779 char *kwnames[] = {
4780 (char *) "self",(char *) "height", NULL
4781 };
4782
4783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHeight",kwnames,&obj0,&obj1)) goto fail;
4784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4785 if (SWIG_arg_fail(1)) SWIG_fail;
4786 {
4787 arg2 = (int)(SWIG_As_int(obj1));
4788 if (SWIG_arg_fail(2)) SWIG_fail;
4789 }
4790 {
4791 PyThreadState* __tstate = wxPyBeginAllowThreads();
4792 (arg1)->SetHeight(arg2);
4793
4794 wxPyEndAllowThreads(__tstate);
4795 if (PyErr_Occurred()) SWIG_fail;
4796 }
4797 Py_INCREF(Py_None); resultobj = Py_None;
4798 return resultobj;
4799 fail:
4800 return NULL;
4801 }
4802
4803
4804 static PyObject *_wrap_Bitmap_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4805 PyObject *resultobj;
4806 wxBitmap *arg1 = (wxBitmap *) 0 ;
4807 int arg2 ;
4808 PyObject * obj0 = 0 ;
4809 PyObject * obj1 = 0 ;
4810 char *kwnames[] = {
4811 (char *) "self",(char *) "width", NULL
4812 };
4813
4814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetWidth",kwnames,&obj0,&obj1)) goto fail;
4815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4816 if (SWIG_arg_fail(1)) SWIG_fail;
4817 {
4818 arg2 = (int)(SWIG_As_int(obj1));
4819 if (SWIG_arg_fail(2)) SWIG_fail;
4820 }
4821 {
4822 PyThreadState* __tstate = wxPyBeginAllowThreads();
4823 (arg1)->SetWidth(arg2);
4824
4825 wxPyEndAllowThreads(__tstate);
4826 if (PyErr_Occurred()) SWIG_fail;
4827 }
4828 Py_INCREF(Py_None); resultobj = Py_None;
4829 return resultobj;
4830 fail:
4831 return NULL;
4832 }
4833
4834
4835 static PyObject *_wrap_Bitmap_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4836 PyObject *resultobj;
4837 wxBitmap *arg1 = (wxBitmap *) 0 ;
4838 int arg2 ;
4839 PyObject * obj0 = 0 ;
4840 PyObject * obj1 = 0 ;
4841 char *kwnames[] = {
4842 (char *) "self",(char *) "depth", NULL
4843 };
4844
4845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetDepth",kwnames,&obj0,&obj1)) goto fail;
4846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4847 if (SWIG_arg_fail(1)) SWIG_fail;
4848 {
4849 arg2 = (int)(SWIG_As_int(obj1));
4850 if (SWIG_arg_fail(2)) SWIG_fail;
4851 }
4852 {
4853 PyThreadState* __tstate = wxPyBeginAllowThreads();
4854 (arg1)->SetDepth(arg2);
4855
4856 wxPyEndAllowThreads(__tstate);
4857 if (PyErr_Occurred()) SWIG_fail;
4858 }
4859 Py_INCREF(Py_None); resultobj = Py_None;
4860 return resultobj;
4861 fail:
4862 return NULL;
4863 }
4864
4865
4866 static PyObject *_wrap_Bitmap_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4867 PyObject *resultobj;
4868 wxBitmap *arg1 = (wxBitmap *) 0 ;
4869 wxSize *arg2 = 0 ;
4870 wxSize temp2 ;
4871 PyObject * obj0 = 0 ;
4872 PyObject * obj1 = 0 ;
4873 char *kwnames[] = {
4874 (char *) "self",(char *) "size", NULL
4875 };
4876
4877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetSize",kwnames,&obj0,&obj1)) goto fail;
4878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4879 if (SWIG_arg_fail(1)) SWIG_fail;
4880 {
4881 arg2 = &temp2;
4882 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4883 }
4884 {
4885 PyThreadState* __tstate = wxPyBeginAllowThreads();
4886 wxBitmap_SetSize(arg1,(wxSize const &)*arg2);
4887
4888 wxPyEndAllowThreads(__tstate);
4889 if (PyErr_Occurred()) SWIG_fail;
4890 }
4891 Py_INCREF(Py_None); resultobj = Py_None;
4892 return resultobj;
4893 fail:
4894 return NULL;
4895 }
4896
4897
4898 static PyObject *_wrap_Bitmap___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4899 PyObject *resultobj;
4900 wxBitmap *arg1 = (wxBitmap *) 0 ;
4901 wxBitmap *arg2 = (wxBitmap *) 0 ;
4902 bool result;
4903 PyObject * obj0 = 0 ;
4904 PyObject * obj1 = 0 ;
4905 char *kwnames[] = {
4906 (char *) "self",(char *) "other", NULL
4907 };
4908
4909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___eq__",kwnames,&obj0,&obj1)) goto fail;
4910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4911 if (SWIG_arg_fail(1)) SWIG_fail;
4912 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4913 if (SWIG_arg_fail(2)) SWIG_fail;
4914 {
4915 PyThreadState* __tstate = wxPyBeginAllowThreads();
4916 result = (bool)wxBitmap___eq__(arg1,(wxBitmap const *)arg2);
4917
4918 wxPyEndAllowThreads(__tstate);
4919 if (PyErr_Occurred()) SWIG_fail;
4920 }
4921 {
4922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4923 }
4924 return resultobj;
4925 fail:
4926 return NULL;
4927 }
4928
4929
4930 static PyObject *_wrap_Bitmap___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4931 PyObject *resultobj;
4932 wxBitmap *arg1 = (wxBitmap *) 0 ;
4933 wxBitmap *arg2 = (wxBitmap *) 0 ;
4934 bool result;
4935 PyObject * obj0 = 0 ;
4936 PyObject * obj1 = 0 ;
4937 char *kwnames[] = {
4938 (char *) "self",(char *) "other", NULL
4939 };
4940
4941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___ne__",kwnames,&obj0,&obj1)) goto fail;
4942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4943 if (SWIG_arg_fail(1)) SWIG_fail;
4944 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4945 if (SWIG_arg_fail(2)) SWIG_fail;
4946 {
4947 PyThreadState* __tstate = wxPyBeginAllowThreads();
4948 result = (bool)wxBitmap___ne__(arg1,(wxBitmap const *)arg2);
4949
4950 wxPyEndAllowThreads(__tstate);
4951 if (PyErr_Occurred()) SWIG_fail;
4952 }
4953 {
4954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4955 }
4956 return resultobj;
4957 fail:
4958 return NULL;
4959 }
4960
4961
4962 static PyObject * Bitmap_swigregister(PyObject *, PyObject *args) {
4963 PyObject *obj;
4964 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4965 SWIG_TypeClientData(SWIGTYPE_p_wxBitmap, obj);
4966 Py_INCREF(obj);
4967 return Py_BuildValue((char *)"");
4968 }
4969 static PyObject *_wrap_new_Mask(PyObject *, PyObject *args, PyObject *kwargs) {
4970 PyObject *resultobj;
4971 wxBitmap *arg1 = 0 ;
4972 wxColour const &arg2_defvalue = wxNullColour ;
4973 wxColour *arg2 = (wxColour *) &arg2_defvalue ;
4974 wxMask *result;
4975 wxColour temp2 ;
4976 PyObject * obj0 = 0 ;
4977 PyObject * obj1 = 0 ;
4978 char *kwnames[] = {
4979 (char *) "bitmap",(char *) "colour", NULL
4980 };
4981
4982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Mask",kwnames,&obj0,&obj1)) goto fail;
4983 {
4984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4985 if (SWIG_arg_fail(1)) SWIG_fail;
4986 if (arg1 == NULL) {
4987 SWIG_null_ref("wxBitmap");
4988 }
4989 if (SWIG_arg_fail(1)) SWIG_fail;
4990 }
4991 if (obj1) {
4992 {
4993 arg2 = &temp2;
4994 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4995 }
4996 }
4997 {
4998 if (!wxPyCheckForApp()) SWIG_fail;
4999 PyThreadState* __tstate = wxPyBeginAllowThreads();
5000 result = (wxMask *)new_wxMask((wxBitmap const &)*arg1,(wxColour const &)*arg2);
5001
5002 wxPyEndAllowThreads(__tstate);
5003 if (PyErr_Occurred()) SWIG_fail;
5004 }
5005 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 1);
5006 return resultobj;
5007 fail:
5008 return NULL;
5009 }
5010
5011
5012 static PyObject * Mask_swigregister(PyObject *, PyObject *args) {
5013 PyObject *obj;
5014 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5015 SWIG_TypeClientData(SWIGTYPE_p_wxMask, obj);
5016 Py_INCREF(obj);
5017 return Py_BuildValue((char *)"");
5018 }
5019 static PyObject *_wrap_new_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
5020 PyObject *resultobj;
5021 wxString *arg1 = 0 ;
5022 wxBitmapType arg2 ;
5023 int arg3 = (int) -1 ;
5024 int arg4 = (int) -1 ;
5025 wxIcon *result;
5026 bool temp1 = false ;
5027 PyObject * obj0 = 0 ;
5028 PyObject * obj1 = 0 ;
5029 PyObject * obj2 = 0 ;
5030 PyObject * obj3 = 0 ;
5031 char *kwnames[] = {
5032 (char *) "name",(char *) "type",(char *) "desiredWidth",(char *) "desiredHeight", NULL
5033 };
5034
5035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Icon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5036 {
5037 arg1 = wxString_in_helper(obj0);
5038 if (arg1 == NULL) SWIG_fail;
5039 temp1 = true;
5040 }
5041 {
5042 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
5043 if (SWIG_arg_fail(2)) SWIG_fail;
5044 }
5045 if (obj2) {
5046 {
5047 arg3 = (int)(SWIG_As_int(obj2));
5048 if (SWIG_arg_fail(3)) SWIG_fail;
5049 }
5050 }
5051 if (obj3) {
5052 {
5053 arg4 = (int)(SWIG_As_int(obj3));
5054 if (SWIG_arg_fail(4)) SWIG_fail;
5055 }
5056 }
5057 {
5058 if (!wxPyCheckForApp()) SWIG_fail;
5059 PyThreadState* __tstate = wxPyBeginAllowThreads();
5060 result = (wxIcon *)new wxIcon((wxString const &)*arg1,(wxBitmapType )arg2,arg3,arg4);
5061
5062 wxPyEndAllowThreads(__tstate);
5063 if (PyErr_Occurred()) SWIG_fail;
5064 }
5065 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5066 {
5067 if (temp1)
5068 delete arg1;
5069 }
5070 return resultobj;
5071 fail:
5072 {
5073 if (temp1)
5074 delete arg1;
5075 }
5076 return NULL;
5077 }
5078
5079
5080 static PyObject *_wrap_delete_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
5081 PyObject *resultobj;
5082 wxIcon *arg1 = (wxIcon *) 0 ;
5083 PyObject * obj0 = 0 ;
5084 char *kwnames[] = {
5085 (char *) "self", NULL
5086 };
5087
5088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Icon",kwnames,&obj0)) goto fail;
5089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5090 if (SWIG_arg_fail(1)) SWIG_fail;
5091 {
5092 PyThreadState* __tstate = wxPyBeginAllowThreads();
5093 delete arg1;
5094
5095 wxPyEndAllowThreads(__tstate);
5096 if (PyErr_Occurred()) SWIG_fail;
5097 }
5098 Py_INCREF(Py_None); resultobj = Py_None;
5099 return resultobj;
5100 fail:
5101 return NULL;
5102 }
5103
5104
5105 static PyObject *_wrap_new_EmptyIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5106 PyObject *resultobj;
5107 wxIcon *result;
5108 char *kwnames[] = {
5109 NULL
5110 };
5111
5112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EmptyIcon",kwnames)) goto fail;
5113 {
5114 if (!wxPyCheckForApp()) SWIG_fail;
5115 PyThreadState* __tstate = wxPyBeginAllowThreads();
5116 result = (wxIcon *)new wxIcon();
5117
5118 wxPyEndAllowThreads(__tstate);
5119 if (PyErr_Occurred()) SWIG_fail;
5120 }
5121 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5122 return resultobj;
5123 fail:
5124 return NULL;
5125 }
5126
5127
5128 static PyObject *_wrap_new_IconFromLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5129 PyObject *resultobj;
5130 wxIconLocation *arg1 = 0 ;
5131 wxIcon *result;
5132 PyObject * obj0 = 0 ;
5133 char *kwnames[] = {
5134 (char *) "loc", NULL
5135 };
5136
5137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromLocation",kwnames,&obj0)) goto fail;
5138 {
5139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5140 if (SWIG_arg_fail(1)) SWIG_fail;
5141 if (arg1 == NULL) {
5142 SWIG_null_ref("wxIconLocation");
5143 }
5144 if (SWIG_arg_fail(1)) SWIG_fail;
5145 }
5146 {
5147 if (!wxPyCheckForApp()) SWIG_fail;
5148 PyThreadState* __tstate = wxPyBeginAllowThreads();
5149 result = (wxIcon *)new wxIcon((wxIconLocation const &)*arg1);
5150
5151 wxPyEndAllowThreads(__tstate);
5152 if (PyErr_Occurred()) SWIG_fail;
5153 }
5154 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5155 return resultobj;
5156 fail:
5157 return NULL;
5158 }
5159
5160
5161 static PyObject *_wrap_new_IconFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5162 PyObject *resultobj;
5163 wxBitmap *arg1 = 0 ;
5164 wxIcon *result;
5165 PyObject * obj0 = 0 ;
5166 char *kwnames[] = {
5167 (char *) "bmp", NULL
5168 };
5169
5170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromBitmap",kwnames,&obj0)) goto fail;
5171 {
5172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5173 if (SWIG_arg_fail(1)) SWIG_fail;
5174 if (arg1 == NULL) {
5175 SWIG_null_ref("wxBitmap");
5176 }
5177 if (SWIG_arg_fail(1)) SWIG_fail;
5178 }
5179 {
5180 if (!wxPyCheckForApp()) SWIG_fail;
5181 PyThreadState* __tstate = wxPyBeginAllowThreads();
5182 result = (wxIcon *)new_wxIcon((wxBitmap const &)*arg1);
5183
5184 wxPyEndAllowThreads(__tstate);
5185 if (PyErr_Occurred()) SWIG_fail;
5186 }
5187 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5188 return resultobj;
5189 fail:
5190 return NULL;
5191 }
5192
5193
5194 static PyObject *_wrap_new_IconFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
5195 PyObject *resultobj;
5196 PyObject *arg1 = (PyObject *) 0 ;
5197 wxIcon *result;
5198 PyObject * obj0 = 0 ;
5199 char *kwnames[] = {
5200 (char *) "listOfStrings", NULL
5201 };
5202
5203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromXPMData",kwnames,&obj0)) goto fail;
5204 arg1 = obj0;
5205 {
5206 if (!wxPyCheckForApp()) SWIG_fail;
5207 PyThreadState* __tstate = wxPyBeginAllowThreads();
5208 result = (wxIcon *)new_wxIcon(arg1);
5209
5210 wxPyEndAllowThreads(__tstate);
5211 if (PyErr_Occurred()) SWIG_fail;
5212 }
5213 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5214 return resultobj;
5215 fail:
5216 return NULL;
5217 }
5218
5219
5220 static PyObject *_wrap_Icon_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
5221 PyObject *resultobj;
5222 wxIcon *arg1 = (wxIcon *) 0 ;
5223 bool result;
5224 PyObject * obj0 = 0 ;
5225 char *kwnames[] = {
5226 (char *) "self", NULL
5227 };
5228
5229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_Ok",kwnames,&obj0)) goto fail;
5230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5231 if (SWIG_arg_fail(1)) SWIG_fail;
5232 {
5233 PyThreadState* __tstate = wxPyBeginAllowThreads();
5234 result = (bool)(arg1)->Ok();
5235
5236 wxPyEndAllowThreads(__tstate);
5237 if (PyErr_Occurred()) SWIG_fail;
5238 }
5239 {
5240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5241 }
5242 return resultobj;
5243 fail:
5244 return NULL;
5245 }
5246
5247
5248 static PyObject *_wrap_Icon_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5249 PyObject *resultobj;
5250 wxIcon *arg1 = (wxIcon *) 0 ;
5251 int result;
5252 PyObject * obj0 = 0 ;
5253 char *kwnames[] = {
5254 (char *) "self", NULL
5255 };
5256
5257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetWidth",kwnames,&obj0)) goto fail;
5258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5259 if (SWIG_arg_fail(1)) SWIG_fail;
5260 {
5261 PyThreadState* __tstate = wxPyBeginAllowThreads();
5262 result = (int)(arg1)->GetWidth();
5263
5264 wxPyEndAllowThreads(__tstate);
5265 if (PyErr_Occurred()) SWIG_fail;
5266 }
5267 {
5268 resultobj = SWIG_From_int((int)(result));
5269 }
5270 return resultobj;
5271 fail:
5272 return NULL;
5273 }
5274
5275
5276 static PyObject *_wrap_Icon_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5277 PyObject *resultobj;
5278 wxIcon *arg1 = (wxIcon *) 0 ;
5279 int result;
5280 PyObject * obj0 = 0 ;
5281 char *kwnames[] = {
5282 (char *) "self", NULL
5283 };
5284
5285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetHeight",kwnames,&obj0)) goto fail;
5286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5287 if (SWIG_arg_fail(1)) SWIG_fail;
5288 {
5289 PyThreadState* __tstate = wxPyBeginAllowThreads();
5290 result = (int)(arg1)->GetHeight();
5291
5292 wxPyEndAllowThreads(__tstate);
5293 if (PyErr_Occurred()) SWIG_fail;
5294 }
5295 {
5296 resultobj = SWIG_From_int((int)(result));
5297 }
5298 return resultobj;
5299 fail:
5300 return NULL;
5301 }
5302
5303
5304 static PyObject *_wrap_Icon_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5305 PyObject *resultobj;
5306 wxIcon *arg1 = (wxIcon *) 0 ;
5307 int result;
5308 PyObject * obj0 = 0 ;
5309 char *kwnames[] = {
5310 (char *) "self", NULL
5311 };
5312
5313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetDepth",kwnames,&obj0)) goto fail;
5314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5315 if (SWIG_arg_fail(1)) SWIG_fail;
5316 {
5317 PyThreadState* __tstate = wxPyBeginAllowThreads();
5318 result = (int)(arg1)->GetDepth();
5319
5320 wxPyEndAllowThreads(__tstate);
5321 if (PyErr_Occurred()) SWIG_fail;
5322 }
5323 {
5324 resultobj = SWIG_From_int((int)(result));
5325 }
5326 return resultobj;
5327 fail:
5328 return NULL;
5329 }
5330
5331
5332 static PyObject *_wrap_Icon_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5333 PyObject *resultobj;
5334 wxIcon *arg1 = (wxIcon *) 0 ;
5335 int arg2 ;
5336 PyObject * obj0 = 0 ;
5337 PyObject * obj1 = 0 ;
5338 char *kwnames[] = {
5339 (char *) "self",(char *) "w", NULL
5340 };
5341
5342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5344 if (SWIG_arg_fail(1)) SWIG_fail;
5345 {
5346 arg2 = (int)(SWIG_As_int(obj1));
5347 if (SWIG_arg_fail(2)) SWIG_fail;
5348 }
5349 {
5350 PyThreadState* __tstate = wxPyBeginAllowThreads();
5351 (arg1)->SetWidth(arg2);
5352
5353 wxPyEndAllowThreads(__tstate);
5354 if (PyErr_Occurred()) SWIG_fail;
5355 }
5356 Py_INCREF(Py_None); resultobj = Py_None;
5357 return resultobj;
5358 fail:
5359 return NULL;
5360 }
5361
5362
5363 static PyObject *_wrap_Icon_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5364 PyObject *resultobj;
5365 wxIcon *arg1 = (wxIcon *) 0 ;
5366 int arg2 ;
5367 PyObject * obj0 = 0 ;
5368 PyObject * obj1 = 0 ;
5369 char *kwnames[] = {
5370 (char *) "self",(char *) "h", NULL
5371 };
5372
5373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5375 if (SWIG_arg_fail(1)) SWIG_fail;
5376 {
5377 arg2 = (int)(SWIG_As_int(obj1));
5378 if (SWIG_arg_fail(2)) SWIG_fail;
5379 }
5380 {
5381 PyThreadState* __tstate = wxPyBeginAllowThreads();
5382 (arg1)->SetHeight(arg2);
5383
5384 wxPyEndAllowThreads(__tstate);
5385 if (PyErr_Occurred()) SWIG_fail;
5386 }
5387 Py_INCREF(Py_None); resultobj = Py_None;
5388 return resultobj;
5389 fail:
5390 return NULL;
5391 }
5392
5393
5394 static PyObject *_wrap_Icon_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5395 PyObject *resultobj;
5396 wxIcon *arg1 = (wxIcon *) 0 ;
5397 int arg2 ;
5398 PyObject * obj0 = 0 ;
5399 PyObject * obj1 = 0 ;
5400 char *kwnames[] = {
5401 (char *) "self",(char *) "d", NULL
5402 };
5403
5404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetDepth",kwnames,&obj0,&obj1)) goto fail;
5405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5406 if (SWIG_arg_fail(1)) SWIG_fail;
5407 {
5408 arg2 = (int)(SWIG_As_int(obj1));
5409 if (SWIG_arg_fail(2)) SWIG_fail;
5410 }
5411 {
5412 PyThreadState* __tstate = wxPyBeginAllowThreads();
5413 (arg1)->SetDepth(arg2);
5414
5415 wxPyEndAllowThreads(__tstate);
5416 if (PyErr_Occurred()) SWIG_fail;
5417 }
5418 Py_INCREF(Py_None); resultobj = Py_None;
5419 return resultobj;
5420 fail:
5421 return NULL;
5422 }
5423
5424
5425 static PyObject *_wrap_Icon_CopyFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5426 PyObject *resultobj;
5427 wxIcon *arg1 = (wxIcon *) 0 ;
5428 wxBitmap *arg2 = 0 ;
5429 PyObject * obj0 = 0 ;
5430 PyObject * obj1 = 0 ;
5431 char *kwnames[] = {
5432 (char *) "self",(char *) "bmp", NULL
5433 };
5434
5435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_CopyFromBitmap",kwnames,&obj0,&obj1)) goto fail;
5436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5437 if (SWIG_arg_fail(1)) SWIG_fail;
5438 {
5439 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5440 if (SWIG_arg_fail(2)) SWIG_fail;
5441 if (arg2 == NULL) {
5442 SWIG_null_ref("wxBitmap");
5443 }
5444 if (SWIG_arg_fail(2)) SWIG_fail;
5445 }
5446 {
5447 PyThreadState* __tstate = wxPyBeginAllowThreads();
5448 (arg1)->CopyFromBitmap((wxBitmap const &)*arg2);
5449
5450 wxPyEndAllowThreads(__tstate);
5451 if (PyErr_Occurred()) SWIG_fail;
5452 }
5453 Py_INCREF(Py_None); resultobj = Py_None;
5454 return resultobj;
5455 fail:
5456 return NULL;
5457 }
5458
5459
5460 static PyObject * Icon_swigregister(PyObject *, PyObject *args) {
5461 PyObject *obj;
5462 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5463 SWIG_TypeClientData(SWIGTYPE_p_wxIcon, obj);
5464 Py_INCREF(obj);
5465 return Py_BuildValue((char *)"");
5466 }
5467 static PyObject *_wrap_new_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5468 PyObject *resultobj;
5469 wxString *arg1 = (wxString *) &wxPyEmptyString ;
5470 int arg2 = (int) 0 ;
5471 wxIconLocation *result;
5472 bool temp1 = false ;
5473 PyObject * obj0 = 0 ;
5474 PyObject * obj1 = 0 ;
5475 char *kwnames[] = {
5476 (char *) "filename",(char *) "num", NULL
5477 };
5478
5479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconLocation",kwnames,&obj0,&obj1)) goto fail;
5480 if (obj0) {
5481 {
5482 arg1 = wxString_in_helper(obj0);
5483 if (arg1 == NULL) SWIG_fail;
5484 temp1 = true;
5485 }
5486 }
5487 if (obj1) {
5488 {
5489 arg2 = (int)(SWIG_As_int(obj1));
5490 if (SWIG_arg_fail(2)) SWIG_fail;
5491 }
5492 }
5493 {
5494 PyThreadState* __tstate = wxPyBeginAllowThreads();
5495 result = (wxIconLocation *)new_wxIconLocation((wxString const *)arg1,arg2);
5496
5497 wxPyEndAllowThreads(__tstate);
5498 if (PyErr_Occurred()) SWIG_fail;
5499 }
5500 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconLocation, 1);
5501 {
5502 if (temp1)
5503 delete arg1;
5504 }
5505 return resultobj;
5506 fail:
5507 {
5508 if (temp1)
5509 delete arg1;
5510 }
5511 return NULL;
5512 }
5513
5514
5515 static PyObject *_wrap_delete_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5516 PyObject *resultobj;
5517 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5518 PyObject * obj0 = 0 ;
5519 char *kwnames[] = {
5520 (char *) "self", NULL
5521 };
5522
5523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconLocation",kwnames,&obj0)) goto fail;
5524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5525 if (SWIG_arg_fail(1)) SWIG_fail;
5526 {
5527 PyThreadState* __tstate = wxPyBeginAllowThreads();
5528 delete arg1;
5529
5530 wxPyEndAllowThreads(__tstate);
5531 if (PyErr_Occurred()) SWIG_fail;
5532 }
5533 Py_INCREF(Py_None); resultobj = Py_None;
5534 return resultobj;
5535 fail:
5536 return NULL;
5537 }
5538
5539
5540 static PyObject *_wrap_IconLocation_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
5541 PyObject *resultobj;
5542 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5543 bool result;
5544 PyObject * obj0 = 0 ;
5545 char *kwnames[] = {
5546 (char *) "self", NULL
5547 };
5548
5549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_IsOk",kwnames,&obj0)) goto fail;
5550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5551 if (SWIG_arg_fail(1)) SWIG_fail;
5552 {
5553 PyThreadState* __tstate = wxPyBeginAllowThreads();
5554 result = (bool)((wxIconLocation const *)arg1)->IsOk();
5555
5556 wxPyEndAllowThreads(__tstate);
5557 if (PyErr_Occurred()) SWIG_fail;
5558 }
5559 {
5560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5561 }
5562 return resultobj;
5563 fail:
5564 return NULL;
5565 }
5566
5567
5568 static PyObject *_wrap_IconLocation_SetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5569 PyObject *resultobj;
5570 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5571 wxString *arg2 = 0 ;
5572 bool temp2 = false ;
5573 PyObject * obj0 = 0 ;
5574 PyObject * obj1 = 0 ;
5575 char *kwnames[] = {
5576 (char *) "self",(char *) "filename", NULL
5577 };
5578
5579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetFileName",kwnames,&obj0,&obj1)) goto fail;
5580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5581 if (SWIG_arg_fail(1)) SWIG_fail;
5582 {
5583 arg2 = wxString_in_helper(obj1);
5584 if (arg2 == NULL) SWIG_fail;
5585 temp2 = true;
5586 }
5587 {
5588 PyThreadState* __tstate = wxPyBeginAllowThreads();
5589 (arg1)->SetFileName((wxString const &)*arg2);
5590
5591 wxPyEndAllowThreads(__tstate);
5592 if (PyErr_Occurred()) SWIG_fail;
5593 }
5594 Py_INCREF(Py_None); resultobj = Py_None;
5595 {
5596 if (temp2)
5597 delete arg2;
5598 }
5599 return resultobj;
5600 fail:
5601 {
5602 if (temp2)
5603 delete arg2;
5604 }
5605 return NULL;
5606 }
5607
5608
5609 static PyObject *_wrap_IconLocation_GetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5610 PyObject *resultobj;
5611 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5612 wxString *result;
5613 PyObject * obj0 = 0 ;
5614 char *kwnames[] = {
5615 (char *) "self", NULL
5616 };
5617
5618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetFileName",kwnames,&obj0)) goto fail;
5619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5620 if (SWIG_arg_fail(1)) SWIG_fail;
5621 {
5622 PyThreadState* __tstate = wxPyBeginAllowThreads();
5623 {
5624 wxString const &_result_ref = ((wxIconLocation const *)arg1)->GetFileName();
5625 result = (wxString *) &_result_ref;
5626 }
5627
5628 wxPyEndAllowThreads(__tstate);
5629 if (PyErr_Occurred()) SWIG_fail;
5630 }
5631 {
5632 #if wxUSE_UNICODE
5633 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
5634 #else
5635 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
5636 #endif
5637 }
5638 return resultobj;
5639 fail:
5640 return NULL;
5641 }
5642
5643
5644 static PyObject *_wrap_IconLocation_SetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5645 PyObject *resultobj;
5646 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5647 int arg2 ;
5648 PyObject * obj0 = 0 ;
5649 PyObject * obj1 = 0 ;
5650 char *kwnames[] = {
5651 (char *) "self",(char *) "num", NULL
5652 };
5653
5654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetIndex",kwnames,&obj0,&obj1)) goto fail;
5655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5656 if (SWIG_arg_fail(1)) SWIG_fail;
5657 {
5658 arg2 = (int)(SWIG_As_int(obj1));
5659 if (SWIG_arg_fail(2)) SWIG_fail;
5660 }
5661 {
5662 PyThreadState* __tstate = wxPyBeginAllowThreads();
5663 wxIconLocation_SetIndex(arg1,arg2);
5664
5665 wxPyEndAllowThreads(__tstate);
5666 if (PyErr_Occurred()) SWIG_fail;
5667 }
5668 Py_INCREF(Py_None); resultobj = Py_None;
5669 return resultobj;
5670 fail:
5671 return NULL;
5672 }
5673
5674
5675 static PyObject *_wrap_IconLocation_GetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5676 PyObject *resultobj;
5677 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5678 int result;
5679 PyObject * obj0 = 0 ;
5680 char *kwnames[] = {
5681 (char *) "self", NULL
5682 };
5683
5684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetIndex",kwnames,&obj0)) goto fail;
5685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5686 if (SWIG_arg_fail(1)) SWIG_fail;
5687 {
5688 PyThreadState* __tstate = wxPyBeginAllowThreads();
5689 result = (int)wxIconLocation_GetIndex(arg1);
5690
5691 wxPyEndAllowThreads(__tstate);
5692 if (PyErr_Occurred()) SWIG_fail;
5693 }
5694 {
5695 resultobj = SWIG_From_int((int)(result));
5696 }
5697 return resultobj;
5698 fail:
5699 return NULL;
5700 }
5701
5702
5703 static PyObject * IconLocation_swigregister(PyObject *, PyObject *args) {
5704 PyObject *obj;
5705 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5706 SWIG_TypeClientData(SWIGTYPE_p_wxIconLocation, obj);
5707 Py_INCREF(obj);
5708 return Py_BuildValue((char *)"");
5709 }
5710 static PyObject *_wrap_new_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5711 PyObject *resultobj;
5712 wxIconBundle *result;
5713 char *kwnames[] = {
5714 NULL
5715 };
5716
5717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IconBundle",kwnames)) goto fail;
5718 {
5719 PyThreadState* __tstate = wxPyBeginAllowThreads();
5720 result = (wxIconBundle *)new wxIconBundle();
5721
5722 wxPyEndAllowThreads(__tstate);
5723 if (PyErr_Occurred()) SWIG_fail;
5724 }
5725 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5726 return resultobj;
5727 fail:
5728 return NULL;
5729 }
5730
5731
5732 static PyObject *_wrap_new_IconBundleFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5733 PyObject *resultobj;
5734 wxString *arg1 = 0 ;
5735 long arg2 ;
5736 wxIconBundle *result;
5737 bool temp1 = false ;
5738 PyObject * obj0 = 0 ;
5739 PyObject * obj1 = 0 ;
5740 char *kwnames[] = {
5741 (char *) "file",(char *) "type", NULL
5742 };
5743
5744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_IconBundleFromFile",kwnames,&obj0,&obj1)) goto fail;
5745 {
5746 arg1 = wxString_in_helper(obj0);
5747 if (arg1 == NULL) SWIG_fail;
5748 temp1 = true;
5749 }
5750 {
5751 arg2 = (long)(SWIG_As_long(obj1));
5752 if (SWIG_arg_fail(2)) SWIG_fail;
5753 }
5754 {
5755 PyThreadState* __tstate = wxPyBeginAllowThreads();
5756 result = (wxIconBundle *)new wxIconBundle((wxString const &)*arg1,arg2);
5757
5758 wxPyEndAllowThreads(__tstate);
5759 if (PyErr_Occurred()) SWIG_fail;
5760 }
5761 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5762 {
5763 if (temp1)
5764 delete arg1;
5765 }
5766 return resultobj;
5767 fail:
5768 {
5769 if (temp1)
5770 delete arg1;
5771 }
5772 return NULL;
5773 }
5774
5775
5776 static PyObject *_wrap_new_IconBundleFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5777 PyObject *resultobj;
5778 wxIcon *arg1 = 0 ;
5779 wxIconBundle *result;
5780 PyObject * obj0 = 0 ;
5781 char *kwnames[] = {
5782 (char *) "icon", NULL
5783 };
5784
5785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconBundleFromIcon",kwnames,&obj0)) goto fail;
5786 {
5787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5788 if (SWIG_arg_fail(1)) SWIG_fail;
5789 if (arg1 == NULL) {
5790 SWIG_null_ref("wxIcon");
5791 }
5792 if (SWIG_arg_fail(1)) SWIG_fail;
5793 }
5794 {
5795 PyThreadState* __tstate = wxPyBeginAllowThreads();
5796 result = (wxIconBundle *)new wxIconBundle((wxIcon const &)*arg1);
5797
5798 wxPyEndAllowThreads(__tstate);
5799 if (PyErr_Occurred()) SWIG_fail;
5800 }
5801 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5802 return resultobj;
5803 fail:
5804 return NULL;
5805 }
5806
5807
5808 static PyObject *_wrap_delete_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5809 PyObject *resultobj;
5810 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5811 PyObject * obj0 = 0 ;
5812 char *kwnames[] = {
5813 (char *) "self", NULL
5814 };
5815
5816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconBundle",kwnames,&obj0)) goto fail;
5817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5818 if (SWIG_arg_fail(1)) SWIG_fail;
5819 {
5820 PyThreadState* __tstate = wxPyBeginAllowThreads();
5821 delete arg1;
5822
5823 wxPyEndAllowThreads(__tstate);
5824 if (PyErr_Occurred()) SWIG_fail;
5825 }
5826 Py_INCREF(Py_None); resultobj = Py_None;
5827 return resultobj;
5828 fail:
5829 return NULL;
5830 }
5831
5832
5833 static PyObject *_wrap_IconBundle_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5834 PyObject *resultobj;
5835 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5836 wxIcon *arg2 = 0 ;
5837 PyObject * obj0 = 0 ;
5838 PyObject * obj1 = 0 ;
5839 char *kwnames[] = {
5840 (char *) "self",(char *) "icon", NULL
5841 };
5842
5843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_AddIcon",kwnames,&obj0,&obj1)) goto fail;
5844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5845 if (SWIG_arg_fail(1)) SWIG_fail;
5846 {
5847 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5848 if (SWIG_arg_fail(2)) SWIG_fail;
5849 if (arg2 == NULL) {
5850 SWIG_null_ref("wxIcon");
5851 }
5852 if (SWIG_arg_fail(2)) SWIG_fail;
5853 }
5854 {
5855 PyThreadState* __tstate = wxPyBeginAllowThreads();
5856 (arg1)->AddIcon((wxIcon const &)*arg2);
5857
5858 wxPyEndAllowThreads(__tstate);
5859 if (PyErr_Occurred()) SWIG_fail;
5860 }
5861 Py_INCREF(Py_None); resultobj = Py_None;
5862 return resultobj;
5863 fail:
5864 return NULL;
5865 }
5866
5867
5868 static PyObject *_wrap_IconBundle_AddIconFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5869 PyObject *resultobj;
5870 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5871 wxString *arg2 = 0 ;
5872 long arg3 ;
5873 bool temp2 = false ;
5874 PyObject * obj0 = 0 ;
5875 PyObject * obj1 = 0 ;
5876 PyObject * obj2 = 0 ;
5877 char *kwnames[] = {
5878 (char *) "self",(char *) "file",(char *) "type", NULL
5879 };
5880
5881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IconBundle_AddIconFromFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
5882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5883 if (SWIG_arg_fail(1)) SWIG_fail;
5884 {
5885 arg2 = wxString_in_helper(obj1);
5886 if (arg2 == NULL) SWIG_fail;
5887 temp2 = true;
5888 }
5889 {
5890 arg3 = (long)(SWIG_As_long(obj2));
5891 if (SWIG_arg_fail(3)) SWIG_fail;
5892 }
5893 {
5894 PyThreadState* __tstate = wxPyBeginAllowThreads();
5895 (arg1)->AddIcon((wxString const &)*arg2,arg3);
5896
5897 wxPyEndAllowThreads(__tstate);
5898 if (PyErr_Occurred()) SWIG_fail;
5899 }
5900 Py_INCREF(Py_None); resultobj = Py_None;
5901 {
5902 if (temp2)
5903 delete arg2;
5904 }
5905 return resultobj;
5906 fail:
5907 {
5908 if (temp2)
5909 delete arg2;
5910 }
5911 return NULL;
5912 }
5913
5914
5915 static PyObject *_wrap_IconBundle_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5916 PyObject *resultobj;
5917 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5918 wxSize *arg2 = 0 ;
5919 wxIcon *result;
5920 wxSize temp2 ;
5921 PyObject * obj0 = 0 ;
5922 PyObject * obj1 = 0 ;
5923 char *kwnames[] = {
5924 (char *) "self",(char *) "size", NULL
5925 };
5926
5927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_GetIcon",kwnames,&obj0,&obj1)) goto fail;
5928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5929 if (SWIG_arg_fail(1)) SWIG_fail;
5930 {
5931 arg2 = &temp2;
5932 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5933 }
5934 {
5935 PyThreadState* __tstate = wxPyBeginAllowThreads();
5936 {
5937 wxIcon const &_result_ref = ((wxIconBundle const *)arg1)->GetIcon((wxSize const &)*arg2);
5938 result = (wxIcon *) &_result_ref;
5939 }
5940
5941 wxPyEndAllowThreads(__tstate);
5942 if (PyErr_Occurred()) SWIG_fail;
5943 }
5944 {
5945 wxIcon* resultptr = new wxIcon(*result);
5946 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxIcon, 1);
5947 }
5948 return resultobj;
5949 fail:
5950 return NULL;
5951 }
5952
5953
5954 static PyObject * IconBundle_swigregister(PyObject *, PyObject *args) {
5955 PyObject *obj;
5956 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5957 SWIG_TypeClientData(SWIGTYPE_p_wxIconBundle, obj);
5958 Py_INCREF(obj);
5959 return Py_BuildValue((char *)"");
5960 }
5961 static PyObject *_wrap_new_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
5962 PyObject *resultobj;
5963 wxString *arg1 = 0 ;
5964 long arg2 ;
5965 int arg3 = (int) 0 ;
5966 int arg4 = (int) 0 ;
5967 wxCursor *result;
5968 bool temp1 = false ;
5969 PyObject * obj0 = 0 ;
5970 PyObject * obj1 = 0 ;
5971 PyObject * obj2 = 0 ;
5972 PyObject * obj3 = 0 ;
5973 char *kwnames[] = {
5974 (char *) "cursorName",(char *) "type",(char *) "hotSpotX",(char *) "hotSpotY", NULL
5975 };
5976
5977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Cursor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5978 {
5979 arg1 = wxString_in_helper(obj0);
5980 if (arg1 == NULL) SWIG_fail;
5981 temp1 = true;
5982 }
5983 {
5984 arg2 = (long)(SWIG_As_long(obj1));
5985 if (SWIG_arg_fail(2)) SWIG_fail;
5986 }
5987 if (obj2) {
5988 {
5989 arg3 = (int)(SWIG_As_int(obj2));
5990 if (SWIG_arg_fail(3)) SWIG_fail;
5991 }
5992 }
5993 if (obj3) {
5994 {
5995 arg4 = (int)(SWIG_As_int(obj3));
5996 if (SWIG_arg_fail(4)) SWIG_fail;
5997 }
5998 }
5999 {
6000 if (!wxPyCheckForApp()) SWIG_fail;
6001 PyThreadState* __tstate = wxPyBeginAllowThreads();
6002 result = (wxCursor *)new_wxCursor((wxString const &)*arg1,arg2,arg3,arg4);
6003
6004 wxPyEndAllowThreads(__tstate);
6005 if (PyErr_Occurred()) SWIG_fail;
6006 }
6007 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6008 {
6009 if (temp1)
6010 delete arg1;
6011 }
6012 return resultobj;
6013 fail:
6014 {
6015 if (temp1)
6016 delete arg1;
6017 }
6018 return NULL;
6019 }
6020
6021
6022 static PyObject *_wrap_delete_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
6023 PyObject *resultobj;
6024 wxCursor *arg1 = (wxCursor *) 0 ;
6025 PyObject * obj0 = 0 ;
6026 char *kwnames[] = {
6027 (char *) "self", NULL
6028 };
6029
6030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Cursor",kwnames,&obj0)) goto fail;
6031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6032 if (SWIG_arg_fail(1)) SWIG_fail;
6033 {
6034 PyThreadState* __tstate = wxPyBeginAllowThreads();
6035 delete arg1;
6036
6037 wxPyEndAllowThreads(__tstate);
6038 if (PyErr_Occurred()) SWIG_fail;
6039 }
6040 Py_INCREF(Py_None); resultobj = Py_None;
6041 return resultobj;
6042 fail:
6043 return NULL;
6044 }
6045
6046
6047 static PyObject *_wrap_new_StockCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6048 PyObject *resultobj;
6049 int arg1 ;
6050 wxCursor *result;
6051 PyObject * obj0 = 0 ;
6052 char *kwnames[] = {
6053 (char *) "id", NULL
6054 };
6055
6056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_StockCursor",kwnames,&obj0)) goto fail;
6057 {
6058 arg1 = (int)(SWIG_As_int(obj0));
6059 if (SWIG_arg_fail(1)) SWIG_fail;
6060 }
6061 {
6062 if (!wxPyCheckForApp()) SWIG_fail;
6063 PyThreadState* __tstate = wxPyBeginAllowThreads();
6064 result = (wxCursor *)new wxCursor(arg1);
6065
6066 wxPyEndAllowThreads(__tstate);
6067 if (PyErr_Occurred()) SWIG_fail;
6068 }
6069 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6070 return resultobj;
6071 fail:
6072 return NULL;
6073 }
6074
6075
6076 static PyObject *_wrap_new_CursorFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
6077 PyObject *resultobj;
6078 wxImage *arg1 = 0 ;
6079 wxCursor *result;
6080 PyObject * obj0 = 0 ;
6081 char *kwnames[] = {
6082 (char *) "image", NULL
6083 };
6084
6085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CursorFromImage",kwnames,&obj0)) goto fail;
6086 {
6087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
6088 if (SWIG_arg_fail(1)) SWIG_fail;
6089 if (arg1 == NULL) {
6090 SWIG_null_ref("wxImage");
6091 }
6092 if (SWIG_arg_fail(1)) SWIG_fail;
6093 }
6094 {
6095 if (!wxPyCheckForApp()) SWIG_fail;
6096 PyThreadState* __tstate = wxPyBeginAllowThreads();
6097 result = (wxCursor *)new wxCursor((wxImage const &)*arg1);
6098
6099 wxPyEndAllowThreads(__tstate);
6100 if (PyErr_Occurred()) SWIG_fail;
6101 }
6102 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6103 return resultobj;
6104 fail:
6105 return NULL;
6106 }
6107
6108
6109 static PyObject *_wrap_Cursor_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
6110 PyObject *resultobj;
6111 wxCursor *arg1 = (wxCursor *) 0 ;
6112 bool result;
6113 PyObject * obj0 = 0 ;
6114 char *kwnames[] = {
6115 (char *) "self", NULL
6116 };
6117
6118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_Ok",kwnames,&obj0)) goto fail;
6119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6120 if (SWIG_arg_fail(1)) SWIG_fail;
6121 {
6122 PyThreadState* __tstate = wxPyBeginAllowThreads();
6123 result = (bool)(arg1)->Ok();
6124
6125 wxPyEndAllowThreads(__tstate);
6126 if (PyErr_Occurred()) SWIG_fail;
6127 }
6128 {
6129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6130 }
6131 return resultobj;
6132 fail:
6133 return NULL;
6134 }
6135
6136
6137 static PyObject * Cursor_swigregister(PyObject *, PyObject *args) {
6138 PyObject *obj;
6139 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6140 SWIG_TypeClientData(SWIGTYPE_p_wxCursor, obj);
6141 Py_INCREF(obj);
6142 return Py_BuildValue((char *)"");
6143 }
6144 static PyObject *_wrap_new_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6145 PyObject *resultobj;
6146 int arg1 = (int) 0 ;
6147 int arg2 = (int) 0 ;
6148 int arg3 = (int) 0 ;
6149 int arg4 = (int) 0 ;
6150 wxRegion *result;
6151 PyObject * obj0 = 0 ;
6152 PyObject * obj1 = 0 ;
6153 PyObject * obj2 = 0 ;
6154 PyObject * obj3 = 0 ;
6155 char *kwnames[] = {
6156 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6157 };
6158
6159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Region",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6160 if (obj0) {
6161 {
6162 arg1 = (int)(SWIG_As_int(obj0));
6163 if (SWIG_arg_fail(1)) SWIG_fail;
6164 }
6165 }
6166 if (obj1) {
6167 {
6168 arg2 = (int)(SWIG_As_int(obj1));
6169 if (SWIG_arg_fail(2)) SWIG_fail;
6170 }
6171 }
6172 if (obj2) {
6173 {
6174 arg3 = (int)(SWIG_As_int(obj2));
6175 if (SWIG_arg_fail(3)) SWIG_fail;
6176 }
6177 }
6178 if (obj3) {
6179 {
6180 arg4 = (int)(SWIG_As_int(obj3));
6181 if (SWIG_arg_fail(4)) SWIG_fail;
6182 }
6183 }
6184 {
6185 if (!wxPyCheckForApp()) SWIG_fail;
6186 PyThreadState* __tstate = wxPyBeginAllowThreads();
6187 result = (wxRegion *)new wxRegion(arg1,arg2,arg3,arg4);
6188
6189 wxPyEndAllowThreads(__tstate);
6190 if (PyErr_Occurred()) SWIG_fail;
6191 }
6192 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6193 return resultobj;
6194 fail:
6195 return NULL;
6196 }
6197
6198
6199 static PyObject *_wrap_new_RegionFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6200 PyObject *resultobj;
6201 wxBitmap *arg1 = 0 ;
6202 wxRegion *result;
6203 PyObject * obj0 = 0 ;
6204 char *kwnames[] = {
6205 (char *) "bmp", NULL
6206 };
6207
6208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionFromBitmap",kwnames,&obj0)) goto fail;
6209 {
6210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6211 if (SWIG_arg_fail(1)) SWIG_fail;
6212 if (arg1 == NULL) {
6213 SWIG_null_ref("wxBitmap");
6214 }
6215 if (SWIG_arg_fail(1)) SWIG_fail;
6216 }
6217 {
6218 if (!wxPyCheckForApp()) SWIG_fail;
6219 PyThreadState* __tstate = wxPyBeginAllowThreads();
6220 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1);
6221
6222 wxPyEndAllowThreads(__tstate);
6223 if (PyErr_Occurred()) SWIG_fail;
6224 }
6225 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6226 return resultobj;
6227 fail:
6228 return NULL;
6229 }
6230
6231
6232 static PyObject *_wrap_new_RegionFromBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
6233 PyObject *resultobj;
6234 wxBitmap *arg1 = 0 ;
6235 wxColour *arg2 = 0 ;
6236 int arg3 = (int) 0 ;
6237 wxRegion *result;
6238 wxColour temp2 ;
6239 PyObject * obj0 = 0 ;
6240 PyObject * obj1 = 0 ;
6241 PyObject * obj2 = 0 ;
6242 char *kwnames[] = {
6243 (char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
6244 };
6245
6246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_RegionFromBitmapColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
6247 {
6248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6249 if (SWIG_arg_fail(1)) SWIG_fail;
6250 if (arg1 == NULL) {
6251 SWIG_null_ref("wxBitmap");
6252 }
6253 if (SWIG_arg_fail(1)) SWIG_fail;
6254 }
6255 {
6256 arg2 = &temp2;
6257 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6258 }
6259 if (obj2) {
6260 {
6261 arg3 = (int)(SWIG_As_int(obj2));
6262 if (SWIG_arg_fail(3)) SWIG_fail;
6263 }
6264 }
6265 {
6266 if (!wxPyCheckForApp()) SWIG_fail;
6267 PyThreadState* __tstate = wxPyBeginAllowThreads();
6268 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1,(wxColour const &)*arg2,arg3);
6269
6270 wxPyEndAllowThreads(__tstate);
6271 if (PyErr_Occurred()) SWIG_fail;
6272 }
6273 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6274 return resultobj;
6275 fail:
6276 return NULL;
6277 }
6278
6279
6280 static PyObject *_wrap_new_RegionFromPoints(PyObject *, PyObject *args, PyObject *kwargs) {
6281 PyObject *resultobj;
6282 int arg1 ;
6283 wxPoint *arg2 = (wxPoint *) 0 ;
6284 int arg3 = (int) wxWINDING_RULE ;
6285 wxRegion *result;
6286 PyObject * obj0 = 0 ;
6287 PyObject * obj1 = 0 ;
6288 char *kwnames[] = {
6289 (char *) "points",(char *) "fillStyle", NULL
6290 };
6291
6292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_RegionFromPoints",kwnames,&obj0,&obj1)) goto fail;
6293 {
6294 arg2 = wxPoint_LIST_helper(obj0, &arg1);
6295 if (arg2 == NULL) SWIG_fail;
6296 }
6297 if (obj1) {
6298 {
6299 arg3 = (int)(SWIG_As_int(obj1));
6300 if (SWIG_arg_fail(3)) SWIG_fail;
6301 }
6302 }
6303 {
6304 if (!wxPyCheckForApp()) SWIG_fail;
6305 PyThreadState* __tstate = wxPyBeginAllowThreads();
6306 result = (wxRegion *)new wxRegion(arg1,arg2,arg3);
6307
6308 wxPyEndAllowThreads(__tstate);
6309 if (PyErr_Occurred()) SWIG_fail;
6310 }
6311 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6312 {
6313 if (arg2) delete [] arg2;
6314 }
6315 return resultobj;
6316 fail:
6317 {
6318 if (arg2) delete [] arg2;
6319 }
6320 return NULL;
6321 }
6322
6323
6324 static PyObject *_wrap_delete_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6325 PyObject *resultobj;
6326 wxRegion *arg1 = (wxRegion *) 0 ;
6327 PyObject * obj0 = 0 ;
6328 char *kwnames[] = {
6329 (char *) "self", NULL
6330 };
6331
6332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Region",kwnames,&obj0)) goto fail;
6333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6334 if (SWIG_arg_fail(1)) SWIG_fail;
6335 {
6336 PyThreadState* __tstate = wxPyBeginAllowThreads();
6337 delete arg1;
6338
6339 wxPyEndAllowThreads(__tstate);
6340 if (PyErr_Occurred()) SWIG_fail;
6341 }
6342 Py_INCREF(Py_None); resultobj = Py_None;
6343 return resultobj;
6344 fail:
6345 return NULL;
6346 }
6347
6348
6349 static PyObject *_wrap_Region_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
6350 PyObject *resultobj;
6351 wxRegion *arg1 = (wxRegion *) 0 ;
6352 PyObject * obj0 = 0 ;
6353 char *kwnames[] = {
6354 (char *) "self", NULL
6355 };
6356
6357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_Clear",kwnames,&obj0)) goto fail;
6358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6359 if (SWIG_arg_fail(1)) SWIG_fail;
6360 {
6361 PyThreadState* __tstate = wxPyBeginAllowThreads();
6362 (arg1)->Clear();
6363
6364 wxPyEndAllowThreads(__tstate);
6365 if (PyErr_Occurred()) SWIG_fail;
6366 }
6367 Py_INCREF(Py_None); resultobj = Py_None;
6368 return resultobj;
6369 fail:
6370 return NULL;
6371 }
6372
6373
6374 static PyObject *_wrap_Region_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
6375 PyObject *resultobj;
6376 wxRegion *arg1 = (wxRegion *) 0 ;
6377 int arg2 ;
6378 int arg3 ;
6379 bool result;
6380 PyObject * obj0 = 0 ;
6381 PyObject * obj1 = 0 ;
6382 PyObject * obj2 = 0 ;
6383 char *kwnames[] = {
6384 (char *) "self",(char *) "x",(char *) "y", NULL
6385 };
6386
6387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Offset",kwnames,&obj0,&obj1,&obj2)) goto fail;
6388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6389 if (SWIG_arg_fail(1)) SWIG_fail;
6390 {
6391 arg2 = (int)(SWIG_As_int(obj1));
6392 if (SWIG_arg_fail(2)) SWIG_fail;
6393 }
6394 {
6395 arg3 = (int)(SWIG_As_int(obj2));
6396 if (SWIG_arg_fail(3)) SWIG_fail;
6397 }
6398 {
6399 PyThreadState* __tstate = wxPyBeginAllowThreads();
6400 result = (bool)(arg1)->Offset(arg2,arg3);
6401
6402 wxPyEndAllowThreads(__tstate);
6403 if (PyErr_Occurred()) SWIG_fail;
6404 }
6405 {
6406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6407 }
6408 return resultobj;
6409 fail:
6410 return NULL;
6411 }
6412
6413
6414 static PyObject *_wrap_Region_Contains(PyObject *, PyObject *args, PyObject *kwargs) {
6415 PyObject *resultobj;
6416 wxRegion *arg1 = (wxRegion *) 0 ;
6417 int arg2 ;
6418 int arg3 ;
6419 wxRegionContain result;
6420 PyObject * obj0 = 0 ;
6421 PyObject * obj1 = 0 ;
6422 PyObject * obj2 = 0 ;
6423 char *kwnames[] = {
6424 (char *) "self",(char *) "x",(char *) "y", NULL
6425 };
6426
6427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Contains",kwnames,&obj0,&obj1,&obj2)) goto fail;
6428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6429 if (SWIG_arg_fail(1)) SWIG_fail;
6430 {
6431 arg2 = (int)(SWIG_As_int(obj1));
6432 if (SWIG_arg_fail(2)) SWIG_fail;
6433 }
6434 {
6435 arg3 = (int)(SWIG_As_int(obj2));
6436 if (SWIG_arg_fail(3)) SWIG_fail;
6437 }
6438 {
6439 PyThreadState* __tstate = wxPyBeginAllowThreads();
6440 result = (wxRegionContain)(arg1)->Contains(arg2,arg3);
6441
6442 wxPyEndAllowThreads(__tstate);
6443 if (PyErr_Occurred()) SWIG_fail;
6444 }
6445 resultobj = SWIG_From_int((result));
6446 return resultobj;
6447 fail:
6448 return NULL;
6449 }
6450
6451
6452 static PyObject *_wrap_Region_ContainsPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6453 PyObject *resultobj;
6454 wxRegion *arg1 = (wxRegion *) 0 ;
6455 wxPoint *arg2 = 0 ;
6456 wxRegionContain result;
6457 wxPoint temp2 ;
6458 PyObject * obj0 = 0 ;
6459 PyObject * obj1 = 0 ;
6460 char *kwnames[] = {
6461 (char *) "self",(char *) "pt", NULL
6462 };
6463
6464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsPoint",kwnames,&obj0,&obj1)) goto fail;
6465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6466 if (SWIG_arg_fail(1)) SWIG_fail;
6467 {
6468 arg2 = &temp2;
6469 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6470 }
6471 {
6472 PyThreadState* __tstate = wxPyBeginAllowThreads();
6473 result = (wxRegionContain)(arg1)->Contains((wxPoint const &)*arg2);
6474
6475 wxPyEndAllowThreads(__tstate);
6476 if (PyErr_Occurred()) SWIG_fail;
6477 }
6478 resultobj = SWIG_From_int((result));
6479 return resultobj;
6480 fail:
6481 return NULL;
6482 }
6483
6484
6485 static PyObject *_wrap_Region_ContainsRect(PyObject *, PyObject *args, PyObject *kwargs) {
6486 PyObject *resultobj;
6487 wxRegion *arg1 = (wxRegion *) 0 ;
6488 wxRect *arg2 = 0 ;
6489 wxRegionContain result;
6490 wxRect temp2 ;
6491 PyObject * obj0 = 0 ;
6492 PyObject * obj1 = 0 ;
6493 char *kwnames[] = {
6494 (char *) "self",(char *) "rect", NULL
6495 };
6496
6497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsRect",kwnames,&obj0,&obj1)) goto fail;
6498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6499 if (SWIG_arg_fail(1)) SWIG_fail;
6500 {
6501 arg2 = &temp2;
6502 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6503 }
6504 {
6505 PyThreadState* __tstate = wxPyBeginAllowThreads();
6506 result = (wxRegionContain)(arg1)->Contains((wxRect const &)*arg2);
6507
6508 wxPyEndAllowThreads(__tstate);
6509 if (PyErr_Occurred()) SWIG_fail;
6510 }
6511 resultobj = SWIG_From_int((result));
6512 return resultobj;
6513 fail:
6514 return NULL;
6515 }
6516
6517
6518 static PyObject *_wrap_Region_ContainsRectDim(PyObject *, PyObject *args, PyObject *kwargs) {
6519 PyObject *resultobj;
6520 wxRegion *arg1 = (wxRegion *) 0 ;
6521 int arg2 ;
6522 int arg3 ;
6523 int arg4 ;
6524 int arg5 ;
6525 wxRegionContain result;
6526 PyObject * obj0 = 0 ;
6527 PyObject * obj1 = 0 ;
6528 PyObject * obj2 = 0 ;
6529 PyObject * obj3 = 0 ;
6530 PyObject * obj4 = 0 ;
6531 char *kwnames[] = {
6532 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
6533 };
6534
6535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_ContainsRectDim",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6537 if (SWIG_arg_fail(1)) SWIG_fail;
6538 {
6539 arg2 = (int)(SWIG_As_int(obj1));
6540 if (SWIG_arg_fail(2)) SWIG_fail;
6541 }
6542 {
6543 arg3 = (int)(SWIG_As_int(obj2));
6544 if (SWIG_arg_fail(3)) SWIG_fail;
6545 }
6546 {
6547 arg4 = (int)(SWIG_As_int(obj3));
6548 if (SWIG_arg_fail(4)) SWIG_fail;
6549 }
6550 {
6551 arg5 = (int)(SWIG_As_int(obj4));
6552 if (SWIG_arg_fail(5)) SWIG_fail;
6553 }
6554 {
6555 PyThreadState* __tstate = wxPyBeginAllowThreads();
6556 result = (wxRegionContain)(arg1)->Contains(arg2,arg3,arg4,arg5);
6557
6558 wxPyEndAllowThreads(__tstate);
6559 if (PyErr_Occurred()) SWIG_fail;
6560 }
6561 resultobj = SWIG_From_int((result));
6562 return resultobj;
6563 fail:
6564 return NULL;
6565 }
6566
6567
6568 static PyObject *_wrap_Region_GetBox(PyObject *, PyObject *args, PyObject *kwargs) {
6569 PyObject *resultobj;
6570 wxRegion *arg1 = (wxRegion *) 0 ;
6571 wxRect result;
6572 PyObject * obj0 = 0 ;
6573 char *kwnames[] = {
6574 (char *) "self", NULL
6575 };
6576
6577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_GetBox",kwnames,&obj0)) goto fail;
6578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6579 if (SWIG_arg_fail(1)) SWIG_fail;
6580 {
6581 PyThreadState* __tstate = wxPyBeginAllowThreads();
6582 result = (arg1)->GetBox();
6583
6584 wxPyEndAllowThreads(__tstate);
6585 if (PyErr_Occurred()) SWIG_fail;
6586 }
6587 {
6588 wxRect * resultptr;
6589 resultptr = new wxRect((wxRect &)(result));
6590 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6591 }
6592 return resultobj;
6593 fail:
6594 return NULL;
6595 }
6596
6597
6598 static PyObject *_wrap_Region_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
6599 PyObject *resultobj;
6600 wxRegion *arg1 = (wxRegion *) 0 ;
6601 int arg2 ;
6602 int arg3 ;
6603 int arg4 ;
6604 int arg5 ;
6605 bool result;
6606 PyObject * obj0 = 0 ;
6607 PyObject * obj1 = 0 ;
6608 PyObject * obj2 = 0 ;
6609 PyObject * obj3 = 0 ;
6610 PyObject * obj4 = 0 ;
6611 char *kwnames[] = {
6612 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6613 };
6614
6615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Intersect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6617 if (SWIG_arg_fail(1)) SWIG_fail;
6618 {
6619 arg2 = (int)(SWIG_As_int(obj1));
6620 if (SWIG_arg_fail(2)) SWIG_fail;
6621 }
6622 {
6623 arg3 = (int)(SWIG_As_int(obj2));
6624 if (SWIG_arg_fail(3)) SWIG_fail;
6625 }
6626 {
6627 arg4 = (int)(SWIG_As_int(obj3));
6628 if (SWIG_arg_fail(4)) SWIG_fail;
6629 }
6630 {
6631 arg5 = (int)(SWIG_As_int(obj4));
6632 if (SWIG_arg_fail(5)) SWIG_fail;
6633 }
6634 {
6635 PyThreadState* __tstate = wxPyBeginAllowThreads();
6636 result = (bool)(arg1)->Intersect(arg2,arg3,arg4,arg5);
6637
6638 wxPyEndAllowThreads(__tstate);
6639 if (PyErr_Occurred()) SWIG_fail;
6640 }
6641 {
6642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6643 }
6644 return resultobj;
6645 fail:
6646 return NULL;
6647 }
6648
6649
6650 static PyObject *_wrap_Region_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6651 PyObject *resultobj;
6652 wxRegion *arg1 = (wxRegion *) 0 ;
6653 wxRect *arg2 = 0 ;
6654 bool result;
6655 wxRect temp2 ;
6656 PyObject * obj0 = 0 ;
6657 PyObject * obj1 = 0 ;
6658 char *kwnames[] = {
6659 (char *) "self",(char *) "rect", NULL
6660 };
6661
6662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6664 if (SWIG_arg_fail(1)) SWIG_fail;
6665 {
6666 arg2 = &temp2;
6667 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6668 }
6669 {
6670 PyThreadState* __tstate = wxPyBeginAllowThreads();
6671 result = (bool)(arg1)->Intersect((wxRect const &)*arg2);
6672
6673 wxPyEndAllowThreads(__tstate);
6674 if (PyErr_Occurred()) SWIG_fail;
6675 }
6676 {
6677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6678 }
6679 return resultobj;
6680 fail:
6681 return NULL;
6682 }
6683
6684
6685 static PyObject *_wrap_Region_IntersectRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6686 PyObject *resultobj;
6687 wxRegion *arg1 = (wxRegion *) 0 ;
6688 wxRegion *arg2 = 0 ;
6689 bool result;
6690 PyObject * obj0 = 0 ;
6691 PyObject * obj1 = 0 ;
6692 char *kwnames[] = {
6693 (char *) "self",(char *) "region", NULL
6694 };
6695
6696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRegion",kwnames,&obj0,&obj1)) goto fail;
6697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6698 if (SWIG_arg_fail(1)) SWIG_fail;
6699 {
6700 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6701 if (SWIG_arg_fail(2)) SWIG_fail;
6702 if (arg2 == NULL) {
6703 SWIG_null_ref("wxRegion");
6704 }
6705 if (SWIG_arg_fail(2)) SWIG_fail;
6706 }
6707 {
6708 PyThreadState* __tstate = wxPyBeginAllowThreads();
6709 result = (bool)(arg1)->Intersect((wxRegion const &)*arg2);
6710
6711 wxPyEndAllowThreads(__tstate);
6712 if (PyErr_Occurred()) SWIG_fail;
6713 }
6714 {
6715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6716 }
6717 return resultobj;
6718 fail:
6719 return NULL;
6720 }
6721
6722
6723 static PyObject *_wrap_Region_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
6724 PyObject *resultobj;
6725 wxRegion *arg1 = (wxRegion *) 0 ;
6726 bool result;
6727 PyObject * obj0 = 0 ;
6728 char *kwnames[] = {
6729 (char *) "self", NULL
6730 };
6731
6732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_IsEmpty",kwnames,&obj0)) goto fail;
6733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6734 if (SWIG_arg_fail(1)) SWIG_fail;
6735 {
6736 PyThreadState* __tstate = wxPyBeginAllowThreads();
6737 result = (bool)(arg1)->IsEmpty();
6738
6739 wxPyEndAllowThreads(__tstate);
6740 if (PyErr_Occurred()) SWIG_fail;
6741 }
6742 {
6743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6744 }
6745 return resultobj;
6746 fail:
6747 return NULL;
6748 }
6749
6750
6751 static PyObject *_wrap_Region_Union(PyObject *, PyObject *args, PyObject *kwargs) {
6752 PyObject *resultobj;
6753 wxRegion *arg1 = (wxRegion *) 0 ;
6754 int arg2 ;
6755 int arg3 ;
6756 int arg4 ;
6757 int arg5 ;
6758 bool result;
6759 PyObject * obj0 = 0 ;
6760 PyObject * obj1 = 0 ;
6761 PyObject * obj2 = 0 ;
6762 PyObject * obj3 = 0 ;
6763 PyObject * obj4 = 0 ;
6764 char *kwnames[] = {
6765 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6766 };
6767
6768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Union",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6770 if (SWIG_arg_fail(1)) SWIG_fail;
6771 {
6772 arg2 = (int)(SWIG_As_int(obj1));
6773 if (SWIG_arg_fail(2)) SWIG_fail;
6774 }
6775 {
6776 arg3 = (int)(SWIG_As_int(obj2));
6777 if (SWIG_arg_fail(3)) SWIG_fail;
6778 }
6779 {
6780 arg4 = (int)(SWIG_As_int(obj3));
6781 if (SWIG_arg_fail(4)) SWIG_fail;
6782 }
6783 {
6784 arg5 = (int)(SWIG_As_int(obj4));
6785 if (SWIG_arg_fail(5)) SWIG_fail;
6786 }
6787 {
6788 PyThreadState* __tstate = wxPyBeginAllowThreads();
6789 result = (bool)(arg1)->Union(arg2,arg3,arg4,arg5);
6790
6791 wxPyEndAllowThreads(__tstate);
6792 if (PyErr_Occurred()) SWIG_fail;
6793 }
6794 {
6795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6796 }
6797 return resultobj;
6798 fail:
6799 return NULL;
6800 }
6801
6802
6803 static PyObject *_wrap_Region_UnionRect(PyObject *, PyObject *args, PyObject *kwargs) {
6804 PyObject *resultobj;
6805 wxRegion *arg1 = (wxRegion *) 0 ;
6806 wxRect *arg2 = 0 ;
6807 bool result;
6808 wxRect temp2 ;
6809 PyObject * obj0 = 0 ;
6810 PyObject * obj1 = 0 ;
6811 char *kwnames[] = {
6812 (char *) "self",(char *) "rect", NULL
6813 };
6814
6815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRect",kwnames,&obj0,&obj1)) goto fail;
6816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6817 if (SWIG_arg_fail(1)) SWIG_fail;
6818 {
6819 arg2 = &temp2;
6820 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6821 }
6822 {
6823 PyThreadState* __tstate = wxPyBeginAllowThreads();
6824 result = (bool)(arg1)->Union((wxRect const &)*arg2);
6825
6826 wxPyEndAllowThreads(__tstate);
6827 if (PyErr_Occurred()) SWIG_fail;
6828 }
6829 {
6830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6831 }
6832 return resultobj;
6833 fail:
6834 return NULL;
6835 }
6836
6837
6838 static PyObject *_wrap_Region_UnionRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6839 PyObject *resultobj;
6840 wxRegion *arg1 = (wxRegion *) 0 ;
6841 wxRegion *arg2 = 0 ;
6842 bool result;
6843 PyObject * obj0 = 0 ;
6844 PyObject * obj1 = 0 ;
6845 char *kwnames[] = {
6846 (char *) "self",(char *) "region", NULL
6847 };
6848
6849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRegion",kwnames,&obj0,&obj1)) goto fail;
6850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6851 if (SWIG_arg_fail(1)) SWIG_fail;
6852 {
6853 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6854 if (SWIG_arg_fail(2)) SWIG_fail;
6855 if (arg2 == NULL) {
6856 SWIG_null_ref("wxRegion");
6857 }
6858 if (SWIG_arg_fail(2)) SWIG_fail;
6859 }
6860 {
6861 PyThreadState* __tstate = wxPyBeginAllowThreads();
6862 result = (bool)(arg1)->Union((wxRegion const &)*arg2);
6863
6864 wxPyEndAllowThreads(__tstate);
6865 if (PyErr_Occurred()) SWIG_fail;
6866 }
6867 {
6868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6869 }
6870 return resultobj;
6871 fail:
6872 return NULL;
6873 }
6874
6875
6876 static PyObject *_wrap_Region_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
6877 PyObject *resultobj;
6878 wxRegion *arg1 = (wxRegion *) 0 ;
6879 int arg2 ;
6880 int arg3 ;
6881 int arg4 ;
6882 int arg5 ;
6883 bool result;
6884 PyObject * obj0 = 0 ;
6885 PyObject * obj1 = 0 ;
6886 PyObject * obj2 = 0 ;
6887 PyObject * obj3 = 0 ;
6888 PyObject * obj4 = 0 ;
6889 char *kwnames[] = {
6890 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6891 };
6892
6893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Subtract",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6895 if (SWIG_arg_fail(1)) SWIG_fail;
6896 {
6897 arg2 = (int)(SWIG_As_int(obj1));
6898 if (SWIG_arg_fail(2)) SWIG_fail;
6899 }
6900 {
6901 arg3 = (int)(SWIG_As_int(obj2));
6902 if (SWIG_arg_fail(3)) SWIG_fail;
6903 }
6904 {
6905 arg4 = (int)(SWIG_As_int(obj3));
6906 if (SWIG_arg_fail(4)) SWIG_fail;
6907 }
6908 {
6909 arg5 = (int)(SWIG_As_int(obj4));
6910 if (SWIG_arg_fail(5)) SWIG_fail;
6911 }
6912 {
6913 PyThreadState* __tstate = wxPyBeginAllowThreads();
6914 result = (bool)(arg1)->Subtract(arg2,arg3,arg4,arg5);
6915
6916 wxPyEndAllowThreads(__tstate);
6917 if (PyErr_Occurred()) SWIG_fail;
6918 }
6919 {
6920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6921 }
6922 return resultobj;
6923 fail:
6924 return NULL;
6925 }
6926
6927
6928 static PyObject *_wrap_Region_SubtractRect(PyObject *, PyObject *args, PyObject *kwargs) {
6929 PyObject *resultobj;
6930 wxRegion *arg1 = (wxRegion *) 0 ;
6931 wxRect *arg2 = 0 ;
6932 bool result;
6933 wxRect temp2 ;
6934 PyObject * obj0 = 0 ;
6935 PyObject * obj1 = 0 ;
6936 char *kwnames[] = {
6937 (char *) "self",(char *) "rect", NULL
6938 };
6939
6940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRect",kwnames,&obj0,&obj1)) goto fail;
6941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6942 if (SWIG_arg_fail(1)) SWIG_fail;
6943 {
6944 arg2 = &temp2;
6945 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6946 }
6947 {
6948 PyThreadState* __tstate = wxPyBeginAllowThreads();
6949 result = (bool)(arg1)->Subtract((wxRect const &)*arg2);
6950
6951 wxPyEndAllowThreads(__tstate);
6952 if (PyErr_Occurred()) SWIG_fail;
6953 }
6954 {
6955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6956 }
6957 return resultobj;
6958 fail:
6959 return NULL;
6960 }
6961
6962
6963 static PyObject *_wrap_Region_SubtractRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6964 PyObject *resultobj;
6965 wxRegion *arg1 = (wxRegion *) 0 ;
6966 wxRegion *arg2 = 0 ;
6967 bool result;
6968 PyObject * obj0 = 0 ;
6969 PyObject * obj1 = 0 ;
6970 char *kwnames[] = {
6971 (char *) "self",(char *) "region", NULL
6972 };
6973
6974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRegion",kwnames,&obj0,&obj1)) goto fail;
6975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6976 if (SWIG_arg_fail(1)) SWIG_fail;
6977 {
6978 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6979 if (SWIG_arg_fail(2)) SWIG_fail;
6980 if (arg2 == NULL) {
6981 SWIG_null_ref("wxRegion");
6982 }
6983 if (SWIG_arg_fail(2)) SWIG_fail;
6984 }
6985 {
6986 PyThreadState* __tstate = wxPyBeginAllowThreads();
6987 result = (bool)(arg1)->Subtract((wxRegion const &)*arg2);
6988
6989 wxPyEndAllowThreads(__tstate);
6990 if (PyErr_Occurred()) SWIG_fail;
6991 }
6992 {
6993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6994 }
6995 return resultobj;
6996 fail:
6997 return NULL;
6998 }
6999
7000
7001 static PyObject *_wrap_Region_Xor(PyObject *, PyObject *args, PyObject *kwargs) {
7002 PyObject *resultobj;
7003 wxRegion *arg1 = (wxRegion *) 0 ;
7004 int arg2 ;
7005 int arg3 ;
7006 int arg4 ;
7007 int arg5 ;
7008 bool result;
7009 PyObject * obj0 = 0 ;
7010 PyObject * obj1 = 0 ;
7011 PyObject * obj2 = 0 ;
7012 PyObject * obj3 = 0 ;
7013 PyObject * obj4 = 0 ;
7014 char *kwnames[] = {
7015 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7016 };
7017
7018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Xor",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7020 if (SWIG_arg_fail(1)) SWIG_fail;
7021 {
7022 arg2 = (int)(SWIG_As_int(obj1));
7023 if (SWIG_arg_fail(2)) SWIG_fail;
7024 }
7025 {
7026 arg3 = (int)(SWIG_As_int(obj2));
7027 if (SWIG_arg_fail(3)) SWIG_fail;
7028 }
7029 {
7030 arg4 = (int)(SWIG_As_int(obj3));
7031 if (SWIG_arg_fail(4)) SWIG_fail;
7032 }
7033 {
7034 arg5 = (int)(SWIG_As_int(obj4));
7035 if (SWIG_arg_fail(5)) SWIG_fail;
7036 }
7037 {
7038 PyThreadState* __tstate = wxPyBeginAllowThreads();
7039 result = (bool)(arg1)->Xor(arg2,arg3,arg4,arg5);
7040
7041 wxPyEndAllowThreads(__tstate);
7042 if (PyErr_Occurred()) SWIG_fail;
7043 }
7044 {
7045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7046 }
7047 return resultobj;
7048 fail:
7049 return NULL;
7050 }
7051
7052
7053 static PyObject *_wrap_Region_XorRect(PyObject *, PyObject *args, PyObject *kwargs) {
7054 PyObject *resultobj;
7055 wxRegion *arg1 = (wxRegion *) 0 ;
7056 wxRect *arg2 = 0 ;
7057 bool result;
7058 wxRect temp2 ;
7059 PyObject * obj0 = 0 ;
7060 PyObject * obj1 = 0 ;
7061 char *kwnames[] = {
7062 (char *) "self",(char *) "rect", NULL
7063 };
7064
7065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRect",kwnames,&obj0,&obj1)) goto fail;
7066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7067 if (SWIG_arg_fail(1)) SWIG_fail;
7068 {
7069 arg2 = &temp2;
7070 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7071 }
7072 {
7073 PyThreadState* __tstate = wxPyBeginAllowThreads();
7074 result = (bool)(arg1)->Xor((wxRect const &)*arg2);
7075
7076 wxPyEndAllowThreads(__tstate);
7077 if (PyErr_Occurred()) SWIG_fail;
7078 }
7079 {
7080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7081 }
7082 return resultobj;
7083 fail:
7084 return NULL;
7085 }
7086
7087
7088 static PyObject *_wrap_Region_XorRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7089 PyObject *resultobj;
7090 wxRegion *arg1 = (wxRegion *) 0 ;
7091 wxRegion *arg2 = 0 ;
7092 bool result;
7093 PyObject * obj0 = 0 ;
7094 PyObject * obj1 = 0 ;
7095 char *kwnames[] = {
7096 (char *) "self",(char *) "region", NULL
7097 };
7098
7099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRegion",kwnames,&obj0,&obj1)) goto fail;
7100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7101 if (SWIG_arg_fail(1)) SWIG_fail;
7102 {
7103 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7104 if (SWIG_arg_fail(2)) SWIG_fail;
7105 if (arg2 == NULL) {
7106 SWIG_null_ref("wxRegion");
7107 }
7108 if (SWIG_arg_fail(2)) SWIG_fail;
7109 }
7110 {
7111 PyThreadState* __tstate = wxPyBeginAllowThreads();
7112 result = (bool)(arg1)->Xor((wxRegion const &)*arg2);
7113
7114 wxPyEndAllowThreads(__tstate);
7115 if (PyErr_Occurred()) SWIG_fail;
7116 }
7117 {
7118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7119 }
7120 return resultobj;
7121 fail:
7122 return NULL;
7123 }
7124
7125
7126 static PyObject *_wrap_Region_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7127 PyObject *resultobj;
7128 wxRegion *arg1 = (wxRegion *) 0 ;
7129 SwigValueWrapper<wxBitmap > result;
7130 PyObject * obj0 = 0 ;
7131 char *kwnames[] = {
7132 (char *) "self", NULL
7133 };
7134
7135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_ConvertToBitmap",kwnames,&obj0)) goto fail;
7136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7137 if (SWIG_arg_fail(1)) SWIG_fail;
7138 {
7139 PyThreadState* __tstate = wxPyBeginAllowThreads();
7140 result = (arg1)->ConvertToBitmap();
7141
7142 wxPyEndAllowThreads(__tstate);
7143 if (PyErr_Occurred()) SWIG_fail;
7144 }
7145 {
7146 wxBitmap * resultptr;
7147 resultptr = new wxBitmap((wxBitmap &)(result));
7148 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
7149 }
7150 return resultobj;
7151 fail:
7152 return NULL;
7153 }
7154
7155
7156 static PyObject *_wrap_Region_UnionBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7157 PyObject *resultobj;
7158 wxRegion *arg1 = (wxRegion *) 0 ;
7159 wxBitmap *arg2 = 0 ;
7160 bool result;
7161 PyObject * obj0 = 0 ;
7162 PyObject * obj1 = 0 ;
7163 char *kwnames[] = {
7164 (char *) "self",(char *) "bmp", NULL
7165 };
7166
7167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionBitmap",kwnames,&obj0,&obj1)) goto fail;
7168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7169 if (SWIG_arg_fail(1)) SWIG_fail;
7170 {
7171 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7172 if (SWIG_arg_fail(2)) SWIG_fail;
7173 if (arg2 == NULL) {
7174 SWIG_null_ref("wxBitmap");
7175 }
7176 if (SWIG_arg_fail(2)) SWIG_fail;
7177 }
7178 {
7179 PyThreadState* __tstate = wxPyBeginAllowThreads();
7180 result = (bool)(arg1)->Union((wxBitmap const &)*arg2);
7181
7182 wxPyEndAllowThreads(__tstate);
7183 if (PyErr_Occurred()) SWIG_fail;
7184 }
7185 {
7186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7187 }
7188 return resultobj;
7189 fail:
7190 return NULL;
7191 }
7192
7193
7194 static PyObject *_wrap_Region_UnionBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
7195 PyObject *resultobj;
7196 wxRegion *arg1 = (wxRegion *) 0 ;
7197 wxBitmap *arg2 = 0 ;
7198 wxColour *arg3 = 0 ;
7199 int arg4 = (int) 0 ;
7200 bool result;
7201 wxColour temp3 ;
7202 PyObject * obj0 = 0 ;
7203 PyObject * obj1 = 0 ;
7204 PyObject * obj2 = 0 ;
7205 PyObject * obj3 = 0 ;
7206 char *kwnames[] = {
7207 (char *) "self",(char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
7208 };
7209
7210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Region_UnionBitmapColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7212 if (SWIG_arg_fail(1)) SWIG_fail;
7213 {
7214 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7215 if (SWIG_arg_fail(2)) SWIG_fail;
7216 if (arg2 == NULL) {
7217 SWIG_null_ref("wxBitmap");
7218 }
7219 if (SWIG_arg_fail(2)) SWIG_fail;
7220 }
7221 {
7222 arg3 = &temp3;
7223 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
7224 }
7225 if (obj3) {
7226 {
7227 arg4 = (int)(SWIG_As_int(obj3));
7228 if (SWIG_arg_fail(4)) SWIG_fail;
7229 }
7230 }
7231 {
7232 PyThreadState* __tstate = wxPyBeginAllowThreads();
7233 result = (bool)(arg1)->Union((wxBitmap const &)*arg2,(wxColour const &)*arg3,arg4);
7234
7235 wxPyEndAllowThreads(__tstate);
7236 if (PyErr_Occurred()) SWIG_fail;
7237 }
7238 {
7239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7240 }
7241 return resultobj;
7242 fail:
7243 return NULL;
7244 }
7245
7246
7247 static PyObject * Region_swigregister(PyObject *, PyObject *args) {
7248 PyObject *obj;
7249 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7250 SWIG_TypeClientData(SWIGTYPE_p_wxRegion, obj);
7251 Py_INCREF(obj);
7252 return Py_BuildValue((char *)"");
7253 }
7254 static PyObject *_wrap_new_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7255 PyObject *resultobj;
7256 wxRegion *arg1 = 0 ;
7257 wxRegionIterator *result;
7258 PyObject * obj0 = 0 ;
7259 char *kwnames[] = {
7260 (char *) "region", NULL
7261 };
7262
7263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionIterator",kwnames,&obj0)) goto fail;
7264 {
7265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7266 if (SWIG_arg_fail(1)) SWIG_fail;
7267 if (arg1 == NULL) {
7268 SWIG_null_ref("wxRegion");
7269 }
7270 if (SWIG_arg_fail(1)) SWIG_fail;
7271 }
7272 {
7273 if (!wxPyCheckForApp()) SWIG_fail;
7274 PyThreadState* __tstate = wxPyBeginAllowThreads();
7275 result = (wxRegionIterator *)new wxRegionIterator((wxRegion const &)*arg1);
7276
7277 wxPyEndAllowThreads(__tstate);
7278 if (PyErr_Occurred()) SWIG_fail;
7279 }
7280 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegionIterator, 1);
7281 return resultobj;
7282 fail:
7283 return NULL;
7284 }
7285
7286
7287 static PyObject *_wrap_delete_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7288 PyObject *resultobj;
7289 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7290 PyObject * obj0 = 0 ;
7291 char *kwnames[] = {
7292 (char *) "self", NULL
7293 };
7294
7295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RegionIterator",kwnames,&obj0)) goto fail;
7296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7297 if (SWIG_arg_fail(1)) SWIG_fail;
7298 {
7299 PyThreadState* __tstate = wxPyBeginAllowThreads();
7300 delete arg1;
7301
7302 wxPyEndAllowThreads(__tstate);
7303 if (PyErr_Occurred()) SWIG_fail;
7304 }
7305 Py_INCREF(Py_None); resultobj = Py_None;
7306 return resultobj;
7307 fail:
7308 return NULL;
7309 }
7310
7311
7312 static PyObject *_wrap_RegionIterator_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
7313 PyObject *resultobj;
7314 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7315 int result;
7316 PyObject * obj0 = 0 ;
7317 char *kwnames[] = {
7318 (char *) "self", NULL
7319 };
7320
7321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetX",kwnames,&obj0)) goto fail;
7322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7323 if (SWIG_arg_fail(1)) SWIG_fail;
7324 {
7325 PyThreadState* __tstate = wxPyBeginAllowThreads();
7326 result = (int)(arg1)->GetX();
7327
7328 wxPyEndAllowThreads(__tstate);
7329 if (PyErr_Occurred()) SWIG_fail;
7330 }
7331 {
7332 resultobj = SWIG_From_int((int)(result));
7333 }
7334 return resultobj;
7335 fail:
7336 return NULL;
7337 }
7338
7339
7340 static PyObject *_wrap_RegionIterator_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
7341 PyObject *resultobj;
7342 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7343 int result;
7344 PyObject * obj0 = 0 ;
7345 char *kwnames[] = {
7346 (char *) "self", NULL
7347 };
7348
7349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetY",kwnames,&obj0)) goto fail;
7350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7351 if (SWIG_arg_fail(1)) SWIG_fail;
7352 {
7353 PyThreadState* __tstate = wxPyBeginAllowThreads();
7354 result = (int)(arg1)->GetY();
7355
7356 wxPyEndAllowThreads(__tstate);
7357 if (PyErr_Occurred()) SWIG_fail;
7358 }
7359 {
7360 resultobj = SWIG_From_int((int)(result));
7361 }
7362 return resultobj;
7363 fail:
7364 return NULL;
7365 }
7366
7367
7368 static PyObject *_wrap_RegionIterator_GetW(PyObject *, PyObject *args, PyObject *kwargs) {
7369 PyObject *resultobj;
7370 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7371 int result;
7372 PyObject * obj0 = 0 ;
7373 char *kwnames[] = {
7374 (char *) "self", NULL
7375 };
7376
7377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetW",kwnames,&obj0)) goto fail;
7378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7379 if (SWIG_arg_fail(1)) SWIG_fail;
7380 {
7381 PyThreadState* __tstate = wxPyBeginAllowThreads();
7382 result = (int)(arg1)->GetW();
7383
7384 wxPyEndAllowThreads(__tstate);
7385 if (PyErr_Occurred()) SWIG_fail;
7386 }
7387 {
7388 resultobj = SWIG_From_int((int)(result));
7389 }
7390 return resultobj;
7391 fail:
7392 return NULL;
7393 }
7394
7395
7396 static PyObject *_wrap_RegionIterator_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
7397 PyObject *resultobj;
7398 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7399 int result;
7400 PyObject * obj0 = 0 ;
7401 char *kwnames[] = {
7402 (char *) "self", NULL
7403 };
7404
7405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetWidth",kwnames,&obj0)) goto fail;
7406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7407 if (SWIG_arg_fail(1)) SWIG_fail;
7408 {
7409 PyThreadState* __tstate = wxPyBeginAllowThreads();
7410 result = (int)(arg1)->GetWidth();
7411
7412 wxPyEndAllowThreads(__tstate);
7413 if (PyErr_Occurred()) SWIG_fail;
7414 }
7415 {
7416 resultobj = SWIG_From_int((int)(result));
7417 }
7418 return resultobj;
7419 fail:
7420 return NULL;
7421 }
7422
7423
7424 static PyObject *_wrap_RegionIterator_GetH(PyObject *, PyObject *args, PyObject *kwargs) {
7425 PyObject *resultobj;
7426 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7427 int result;
7428 PyObject * obj0 = 0 ;
7429 char *kwnames[] = {
7430 (char *) "self", NULL
7431 };
7432
7433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetH",kwnames,&obj0)) goto fail;
7434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7435 if (SWIG_arg_fail(1)) SWIG_fail;
7436 {
7437 PyThreadState* __tstate = wxPyBeginAllowThreads();
7438 result = (int)(arg1)->GetH();
7439
7440 wxPyEndAllowThreads(__tstate);
7441 if (PyErr_Occurred()) SWIG_fail;
7442 }
7443 {
7444 resultobj = SWIG_From_int((int)(result));
7445 }
7446 return resultobj;
7447 fail:
7448 return NULL;
7449 }
7450
7451
7452 static PyObject *_wrap_RegionIterator_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
7453 PyObject *resultobj;
7454 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7455 int result;
7456 PyObject * obj0 = 0 ;
7457 char *kwnames[] = {
7458 (char *) "self", NULL
7459 };
7460
7461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetHeight",kwnames,&obj0)) goto fail;
7462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7463 if (SWIG_arg_fail(1)) SWIG_fail;
7464 {
7465 PyThreadState* __tstate = wxPyBeginAllowThreads();
7466 result = (int)(arg1)->GetHeight();
7467
7468 wxPyEndAllowThreads(__tstate);
7469 if (PyErr_Occurred()) SWIG_fail;
7470 }
7471 {
7472 resultobj = SWIG_From_int((int)(result));
7473 }
7474 return resultobj;
7475 fail:
7476 return NULL;
7477 }
7478
7479
7480 static PyObject *_wrap_RegionIterator_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
7481 PyObject *resultobj;
7482 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7483 wxRect result;
7484 PyObject * obj0 = 0 ;
7485 char *kwnames[] = {
7486 (char *) "self", NULL
7487 };
7488
7489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetRect",kwnames,&obj0)) goto fail;
7490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7491 if (SWIG_arg_fail(1)) SWIG_fail;
7492 {
7493 PyThreadState* __tstate = wxPyBeginAllowThreads();
7494 result = (arg1)->GetRect();
7495
7496 wxPyEndAllowThreads(__tstate);
7497 if (PyErr_Occurred()) SWIG_fail;
7498 }
7499 {
7500 wxRect * resultptr;
7501 resultptr = new wxRect((wxRect &)(result));
7502 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
7503 }
7504 return resultobj;
7505 fail:
7506 return NULL;
7507 }
7508
7509
7510 static PyObject *_wrap_RegionIterator_HaveRects(PyObject *, PyObject *args, PyObject *kwargs) {
7511 PyObject *resultobj;
7512 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7513 bool result;
7514 PyObject * obj0 = 0 ;
7515 char *kwnames[] = {
7516 (char *) "self", NULL
7517 };
7518
7519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_HaveRects",kwnames,&obj0)) goto fail;
7520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7521 if (SWIG_arg_fail(1)) SWIG_fail;
7522 {
7523 PyThreadState* __tstate = wxPyBeginAllowThreads();
7524 result = (bool)(arg1)->HaveRects();
7525
7526 wxPyEndAllowThreads(__tstate);
7527 if (PyErr_Occurred()) SWIG_fail;
7528 }
7529 {
7530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7531 }
7532 return resultobj;
7533 fail:
7534 return NULL;
7535 }
7536
7537
7538 static PyObject *_wrap_RegionIterator_Reset(PyObject *, PyObject *args, PyObject *kwargs) {
7539 PyObject *resultobj;
7540 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7541 PyObject * obj0 = 0 ;
7542 char *kwnames[] = {
7543 (char *) "self", NULL
7544 };
7545
7546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Reset",kwnames,&obj0)) goto fail;
7547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7548 if (SWIG_arg_fail(1)) SWIG_fail;
7549 {
7550 PyThreadState* __tstate = wxPyBeginAllowThreads();
7551 (arg1)->Reset();
7552
7553 wxPyEndAllowThreads(__tstate);
7554 if (PyErr_Occurred()) SWIG_fail;
7555 }
7556 Py_INCREF(Py_None); resultobj = Py_None;
7557 return resultobj;
7558 fail:
7559 return NULL;
7560 }
7561
7562
7563 static PyObject *_wrap_RegionIterator_Next(PyObject *, PyObject *args, PyObject *kwargs) {
7564 PyObject *resultobj;
7565 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7566 PyObject * obj0 = 0 ;
7567 char *kwnames[] = {
7568 (char *) "self", NULL
7569 };
7570
7571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Next",kwnames,&obj0)) goto fail;
7572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7573 if (SWIG_arg_fail(1)) SWIG_fail;
7574 {
7575 PyThreadState* __tstate = wxPyBeginAllowThreads();
7576 wxRegionIterator_Next(arg1);
7577
7578 wxPyEndAllowThreads(__tstate);
7579 if (PyErr_Occurred()) SWIG_fail;
7580 }
7581 Py_INCREF(Py_None); resultobj = Py_None;
7582 return resultobj;
7583 fail:
7584 return NULL;
7585 }
7586
7587
7588 static PyObject *_wrap_RegionIterator___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
7589 PyObject *resultobj;
7590 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7591 bool result;
7592 PyObject * obj0 = 0 ;
7593 char *kwnames[] = {
7594 (char *) "self", NULL
7595 };
7596
7597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator___nonzero__",kwnames,&obj0)) goto fail;
7598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7599 if (SWIG_arg_fail(1)) SWIG_fail;
7600 {
7601 PyThreadState* __tstate = wxPyBeginAllowThreads();
7602 result = (bool)wxRegionIterator___nonzero__(arg1);
7603
7604 wxPyEndAllowThreads(__tstate);
7605 if (PyErr_Occurred()) SWIG_fail;
7606 }
7607 {
7608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7609 }
7610 return resultobj;
7611 fail:
7612 return NULL;
7613 }
7614
7615
7616 static PyObject * RegionIterator_swigregister(PyObject *, PyObject *args) {
7617 PyObject *obj;
7618 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7619 SWIG_TypeClientData(SWIGTYPE_p_wxRegionIterator, obj);
7620 Py_INCREF(obj);
7621 return Py_BuildValue((char *)"");
7622 }
7623 static PyObject *_wrap_new_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7624 PyObject *resultobj;
7625 wxNativeFontInfo *result;
7626 char *kwnames[] = {
7627 NULL
7628 };
7629
7630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeFontInfo",kwnames)) goto fail;
7631 {
7632 PyThreadState* __tstate = wxPyBeginAllowThreads();
7633 result = (wxNativeFontInfo *)new wxNativeFontInfo();
7634
7635 wxPyEndAllowThreads(__tstate);
7636 if (PyErr_Occurred()) SWIG_fail;
7637 }
7638 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 1);
7639 return resultobj;
7640 fail:
7641 return NULL;
7642 }
7643
7644
7645 static PyObject *_wrap_delete_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7646 PyObject *resultobj;
7647 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7648 PyObject * obj0 = 0 ;
7649 char *kwnames[] = {
7650 (char *) "self", NULL
7651 };
7652
7653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeFontInfo",kwnames,&obj0)) goto fail;
7654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7655 if (SWIG_arg_fail(1)) SWIG_fail;
7656 {
7657 PyThreadState* __tstate = wxPyBeginAllowThreads();
7658 delete arg1;
7659
7660 wxPyEndAllowThreads(__tstate);
7661 if (PyErr_Occurred()) SWIG_fail;
7662 }
7663 Py_INCREF(Py_None); resultobj = Py_None;
7664 return resultobj;
7665 fail:
7666 return NULL;
7667 }
7668
7669
7670 static PyObject *_wrap_NativeFontInfo_Init(PyObject *, PyObject *args, PyObject *kwargs) {
7671 PyObject *resultobj;
7672 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7673 PyObject * obj0 = 0 ;
7674 char *kwnames[] = {
7675 (char *) "self", NULL
7676 };
7677
7678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_Init",kwnames,&obj0)) goto fail;
7679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7680 if (SWIG_arg_fail(1)) SWIG_fail;
7681 {
7682 PyThreadState* __tstate = wxPyBeginAllowThreads();
7683 (arg1)->Init();
7684
7685 wxPyEndAllowThreads(__tstate);
7686 if (PyErr_Occurred()) SWIG_fail;
7687 }
7688 Py_INCREF(Py_None); resultobj = Py_None;
7689 return resultobj;
7690 fail:
7691 return NULL;
7692 }
7693
7694
7695 static PyObject *_wrap_NativeFontInfo_InitFromFont(PyObject *, PyObject *args, PyObject *kwargs) {
7696 PyObject *resultobj;
7697 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7698 wxFont *arg2 = 0 ;
7699 PyObject * obj0 = 0 ;
7700 PyObject * obj1 = 0 ;
7701 char *kwnames[] = {
7702 (char *) "self",(char *) "font", NULL
7703 };
7704
7705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_InitFromFont",kwnames,&obj0,&obj1)) goto fail;
7706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7707 if (SWIG_arg_fail(1)) SWIG_fail;
7708 {
7709 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
7710 if (SWIG_arg_fail(2)) SWIG_fail;
7711 if (arg2 == NULL) {
7712 SWIG_null_ref("wxFont");
7713 }
7714 if (SWIG_arg_fail(2)) SWIG_fail;
7715 }
7716 {
7717 PyThreadState* __tstate = wxPyBeginAllowThreads();
7718 (arg1)->InitFromFont((wxFont const &)*arg2);
7719
7720 wxPyEndAllowThreads(__tstate);
7721 if (PyErr_Occurred()) SWIG_fail;
7722 }
7723 Py_INCREF(Py_None); resultobj = Py_None;
7724 return resultobj;
7725 fail:
7726 return NULL;
7727 }
7728
7729
7730 static PyObject *_wrap_NativeFontInfo_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
7731 PyObject *resultobj;
7732 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7733 int result;
7734 PyObject * obj0 = 0 ;
7735 char *kwnames[] = {
7736 (char *) "self", NULL
7737 };
7738
7739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetPointSize",kwnames,&obj0)) goto fail;
7740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7741 if (SWIG_arg_fail(1)) SWIG_fail;
7742 {
7743 PyThreadState* __tstate = wxPyBeginAllowThreads();
7744 result = (int)((wxNativeFontInfo const *)arg1)->GetPointSize();
7745
7746 wxPyEndAllowThreads(__tstate);
7747 if (PyErr_Occurred()) SWIG_fail;
7748 }
7749 {
7750 resultobj = SWIG_From_int((int)(result));
7751 }
7752 return resultobj;
7753 fail:
7754 return NULL;
7755 }
7756
7757
7758 static PyObject *_wrap_NativeFontInfo_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
7759 PyObject *resultobj;
7760 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7761 wxFontStyle result;
7762 PyObject * obj0 = 0 ;
7763 char *kwnames[] = {
7764 (char *) "self", NULL
7765 };
7766
7767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetStyle",kwnames,&obj0)) goto fail;
7768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7769 if (SWIG_arg_fail(1)) SWIG_fail;
7770 {
7771 PyThreadState* __tstate = wxPyBeginAllowThreads();
7772 result = (wxFontStyle)((wxNativeFontInfo const *)arg1)->GetStyle();
7773
7774 wxPyEndAllowThreads(__tstate);
7775 if (PyErr_Occurred()) SWIG_fail;
7776 }
7777 resultobj = SWIG_From_int((result));
7778 return resultobj;
7779 fail:
7780 return NULL;
7781 }
7782
7783
7784 static PyObject *_wrap_NativeFontInfo_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
7785 PyObject *resultobj;
7786 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7787 wxFontWeight result;
7788 PyObject * obj0 = 0 ;
7789 char *kwnames[] = {
7790 (char *) "self", NULL
7791 };
7792
7793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetWeight",kwnames,&obj0)) goto fail;
7794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7795 if (SWIG_arg_fail(1)) SWIG_fail;
7796 {
7797 PyThreadState* __tstate = wxPyBeginAllowThreads();
7798 result = (wxFontWeight)((wxNativeFontInfo const *)arg1)->GetWeight();
7799
7800 wxPyEndAllowThreads(__tstate);
7801 if (PyErr_Occurred()) SWIG_fail;
7802 }
7803 resultobj = SWIG_From_int((result));
7804 return resultobj;
7805 fail:
7806 return NULL;
7807 }
7808
7809
7810 static PyObject *_wrap_NativeFontInfo_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
7811 PyObject *resultobj;
7812 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7813 bool result;
7814 PyObject * obj0 = 0 ;
7815 char *kwnames[] = {
7816 (char *) "self", NULL
7817 };
7818
7819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetUnderlined",kwnames,&obj0)) goto fail;
7820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7821 if (SWIG_arg_fail(1)) SWIG_fail;
7822 {
7823 PyThreadState* __tstate = wxPyBeginAllowThreads();
7824 result = (bool)((wxNativeFontInfo const *)arg1)->GetUnderlined();
7825
7826 wxPyEndAllowThreads(__tstate);
7827 if (PyErr_Occurred()) SWIG_fail;
7828 }
7829 {
7830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7831 }
7832 return resultobj;
7833 fail:
7834 return NULL;
7835 }
7836
7837
7838 static PyObject *_wrap_NativeFontInfo_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
7839 PyObject *resultobj;
7840 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7841 wxString result;
7842 PyObject * obj0 = 0 ;
7843 char *kwnames[] = {
7844 (char *) "self", NULL
7845 };
7846
7847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFaceName",kwnames,&obj0)) goto fail;
7848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7849 if (SWIG_arg_fail(1)) SWIG_fail;
7850 {
7851 PyThreadState* __tstate = wxPyBeginAllowThreads();
7852 result = ((wxNativeFontInfo const *)arg1)->GetFaceName();
7853
7854 wxPyEndAllowThreads(__tstate);
7855 if (PyErr_Occurred()) SWIG_fail;
7856 }
7857 {
7858 #if wxUSE_UNICODE
7859 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7860 #else
7861 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7862 #endif
7863 }
7864 return resultobj;
7865 fail:
7866 return NULL;
7867 }
7868
7869
7870 static PyObject *_wrap_NativeFontInfo_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
7871 PyObject *resultobj;
7872 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7873 wxFontFamily result;
7874 PyObject * obj0 = 0 ;
7875 char *kwnames[] = {
7876 (char *) "self", NULL
7877 };
7878
7879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFamily",kwnames,&obj0)) goto fail;
7880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7881 if (SWIG_arg_fail(1)) SWIG_fail;
7882 {
7883 PyThreadState* __tstate = wxPyBeginAllowThreads();
7884 result = (wxFontFamily)((wxNativeFontInfo const *)arg1)->GetFamily();
7885
7886 wxPyEndAllowThreads(__tstate);
7887 if (PyErr_Occurred()) SWIG_fail;
7888 }
7889 resultobj = SWIG_From_int((result));
7890 return resultobj;
7891 fail:
7892 return NULL;
7893 }
7894
7895
7896 static PyObject *_wrap_NativeFontInfo_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
7897 PyObject *resultobj;
7898 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7899 wxFontEncoding result;
7900 PyObject * obj0 = 0 ;
7901 char *kwnames[] = {
7902 (char *) "self", NULL
7903 };
7904
7905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetEncoding",kwnames,&obj0)) goto fail;
7906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7907 if (SWIG_arg_fail(1)) SWIG_fail;
7908 {
7909 PyThreadState* __tstate = wxPyBeginAllowThreads();
7910 result = (wxFontEncoding)((wxNativeFontInfo const *)arg1)->GetEncoding();
7911
7912 wxPyEndAllowThreads(__tstate);
7913 if (PyErr_Occurred()) SWIG_fail;
7914 }
7915 resultobj = SWIG_From_int((result));
7916 return resultobj;
7917 fail:
7918 return NULL;
7919 }
7920
7921
7922 static PyObject *_wrap_NativeFontInfo_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
7923 PyObject *resultobj;
7924 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7925 int arg2 ;
7926 PyObject * obj0 = 0 ;
7927 PyObject * obj1 = 0 ;
7928 char *kwnames[] = {
7929 (char *) "self",(char *) "pointsize", NULL
7930 };
7931
7932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
7933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7934 if (SWIG_arg_fail(1)) SWIG_fail;
7935 {
7936 arg2 = (int)(SWIG_As_int(obj1));
7937 if (SWIG_arg_fail(2)) SWIG_fail;
7938 }
7939 {
7940 PyThreadState* __tstate = wxPyBeginAllowThreads();
7941 (arg1)->SetPointSize(arg2);
7942
7943 wxPyEndAllowThreads(__tstate);
7944 if (PyErr_Occurred()) SWIG_fail;
7945 }
7946 Py_INCREF(Py_None); resultobj = Py_None;
7947 return resultobj;
7948 fail:
7949 return NULL;
7950 }
7951
7952
7953 static PyObject *_wrap_NativeFontInfo_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
7954 PyObject *resultobj;
7955 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7956 wxFontStyle arg2 ;
7957 PyObject * obj0 = 0 ;
7958 PyObject * obj1 = 0 ;
7959 char *kwnames[] = {
7960 (char *) "self",(char *) "style", NULL
7961 };
7962
7963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetStyle",kwnames,&obj0,&obj1)) goto fail;
7964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7965 if (SWIG_arg_fail(1)) SWIG_fail;
7966 {
7967 arg2 = (wxFontStyle)(SWIG_As_int(obj1));
7968 if (SWIG_arg_fail(2)) SWIG_fail;
7969 }
7970 {
7971 PyThreadState* __tstate = wxPyBeginAllowThreads();
7972 (arg1)->SetStyle((wxFontStyle )arg2);
7973
7974 wxPyEndAllowThreads(__tstate);
7975 if (PyErr_Occurred()) SWIG_fail;
7976 }
7977 Py_INCREF(Py_None); resultobj = Py_None;
7978 return resultobj;
7979 fail:
7980 return NULL;
7981 }
7982
7983
7984 static PyObject *_wrap_NativeFontInfo_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
7985 PyObject *resultobj;
7986 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7987 wxFontWeight arg2 ;
7988 PyObject * obj0 = 0 ;
7989 PyObject * obj1 = 0 ;
7990 char *kwnames[] = {
7991 (char *) "self",(char *) "weight", NULL
7992 };
7993
7994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetWeight",kwnames,&obj0,&obj1)) goto fail;
7995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7996 if (SWIG_arg_fail(1)) SWIG_fail;
7997 {
7998 arg2 = (wxFontWeight)(SWIG_As_int(obj1));
7999 if (SWIG_arg_fail(2)) SWIG_fail;
8000 }
8001 {
8002 PyThreadState* __tstate = wxPyBeginAllowThreads();
8003 (arg1)->SetWeight((wxFontWeight )arg2);
8004
8005 wxPyEndAllowThreads(__tstate);
8006 if (PyErr_Occurred()) SWIG_fail;
8007 }
8008 Py_INCREF(Py_None); resultobj = Py_None;
8009 return resultobj;
8010 fail:
8011 return NULL;
8012 }
8013
8014
8015 static PyObject *_wrap_NativeFontInfo_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
8016 PyObject *resultobj;
8017 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8018 bool arg2 ;
8019 PyObject * obj0 = 0 ;
8020 PyObject * obj1 = 0 ;
8021 char *kwnames[] = {
8022 (char *) "self",(char *) "underlined", NULL
8023 };
8024
8025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
8026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8027 if (SWIG_arg_fail(1)) SWIG_fail;
8028 {
8029 arg2 = (bool)(SWIG_As_bool(obj1));
8030 if (SWIG_arg_fail(2)) SWIG_fail;
8031 }
8032 {
8033 PyThreadState* __tstate = wxPyBeginAllowThreads();
8034 (arg1)->SetUnderlined(arg2);
8035
8036 wxPyEndAllowThreads(__tstate);
8037 if (PyErr_Occurred()) SWIG_fail;
8038 }
8039 Py_INCREF(Py_None); resultobj = Py_None;
8040 return resultobj;
8041 fail:
8042 return NULL;
8043 }
8044
8045
8046 static PyObject *_wrap_NativeFontInfo_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
8047 PyObject *resultobj;
8048 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8049 wxString arg2 ;
8050 PyObject * obj0 = 0 ;
8051 PyObject * obj1 = 0 ;
8052 char *kwnames[] = {
8053 (char *) "self",(char *) "facename", NULL
8054 };
8055
8056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
8057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8058 if (SWIG_arg_fail(1)) SWIG_fail;
8059 {
8060 wxString* sptr = wxString_in_helper(obj1);
8061 if (sptr == NULL) SWIG_fail;
8062 arg2 = *sptr;
8063 delete sptr;
8064 }
8065 {
8066 PyThreadState* __tstate = wxPyBeginAllowThreads();
8067 (arg1)->SetFaceName(arg2);
8068
8069 wxPyEndAllowThreads(__tstate);
8070 if (PyErr_Occurred()) SWIG_fail;
8071 }
8072 Py_INCREF(Py_None); resultobj = Py_None;
8073 return resultobj;
8074 fail:
8075 return NULL;
8076 }
8077
8078
8079 static PyObject *_wrap_NativeFontInfo_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
8080 PyObject *resultobj;
8081 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8082 wxFontFamily arg2 ;
8083 PyObject * obj0 = 0 ;
8084 PyObject * obj1 = 0 ;
8085 char *kwnames[] = {
8086 (char *) "self",(char *) "family", NULL
8087 };
8088
8089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFamily",kwnames,&obj0,&obj1)) goto fail;
8090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8091 if (SWIG_arg_fail(1)) SWIG_fail;
8092 {
8093 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
8094 if (SWIG_arg_fail(2)) SWIG_fail;
8095 }
8096 {
8097 PyThreadState* __tstate = wxPyBeginAllowThreads();
8098 (arg1)->SetFamily((wxFontFamily )arg2);
8099
8100 wxPyEndAllowThreads(__tstate);
8101 if (PyErr_Occurred()) SWIG_fail;
8102 }
8103 Py_INCREF(Py_None); resultobj = Py_None;
8104 return resultobj;
8105 fail:
8106 return NULL;
8107 }
8108
8109
8110 static PyObject *_wrap_NativeFontInfo_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8111 PyObject *resultobj;
8112 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8113 wxFontEncoding arg2 ;
8114 PyObject * obj0 = 0 ;
8115 PyObject * obj1 = 0 ;
8116 char *kwnames[] = {
8117 (char *) "self",(char *) "encoding", NULL
8118 };
8119
8120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
8121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8122 if (SWIG_arg_fail(1)) SWIG_fail;
8123 {
8124 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8125 if (SWIG_arg_fail(2)) SWIG_fail;
8126 }
8127 {
8128 PyThreadState* __tstate = wxPyBeginAllowThreads();
8129 (arg1)->SetEncoding((wxFontEncoding )arg2);
8130
8131 wxPyEndAllowThreads(__tstate);
8132 if (PyErr_Occurred()) SWIG_fail;
8133 }
8134 Py_INCREF(Py_None); resultobj = Py_None;
8135 return resultobj;
8136 fail:
8137 return NULL;
8138 }
8139
8140
8141 static PyObject *_wrap_NativeFontInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8142 PyObject *resultobj;
8143 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8144 wxString *arg2 = 0 ;
8145 bool result;
8146 bool temp2 = false ;
8147 PyObject * obj0 = 0 ;
8148 PyObject * obj1 = 0 ;
8149 char *kwnames[] = {
8150 (char *) "self",(char *) "s", NULL
8151 };
8152
8153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8155 if (SWIG_arg_fail(1)) SWIG_fail;
8156 {
8157 arg2 = wxString_in_helper(obj1);
8158 if (arg2 == NULL) SWIG_fail;
8159 temp2 = true;
8160 }
8161 {
8162 PyThreadState* __tstate = wxPyBeginAllowThreads();
8163 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8164
8165 wxPyEndAllowThreads(__tstate);
8166 if (PyErr_Occurred()) SWIG_fail;
8167 }
8168 {
8169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8170 }
8171 {
8172 if (temp2)
8173 delete arg2;
8174 }
8175 return resultobj;
8176 fail:
8177 {
8178 if (temp2)
8179 delete arg2;
8180 }
8181 return NULL;
8182 }
8183
8184
8185 static PyObject *_wrap_NativeFontInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8186 PyObject *resultobj;
8187 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8188 wxString result;
8189 PyObject * obj0 = 0 ;
8190 char *kwnames[] = {
8191 (char *) "self", NULL
8192 };
8193
8194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToString",kwnames,&obj0)) goto fail;
8195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8196 if (SWIG_arg_fail(1)) SWIG_fail;
8197 {
8198 PyThreadState* __tstate = wxPyBeginAllowThreads();
8199 result = ((wxNativeFontInfo const *)arg1)->ToString();
8200
8201 wxPyEndAllowThreads(__tstate);
8202 if (PyErr_Occurred()) SWIG_fail;
8203 }
8204 {
8205 #if wxUSE_UNICODE
8206 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8207 #else
8208 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8209 #endif
8210 }
8211 return resultobj;
8212 fail:
8213 return NULL;
8214 }
8215
8216
8217 static PyObject *_wrap_NativeFontInfo___str__(PyObject *, PyObject *args, PyObject *kwargs) {
8218 PyObject *resultobj;
8219 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8220 wxString result;
8221 PyObject * obj0 = 0 ;
8222 char *kwnames[] = {
8223 (char *) "self", NULL
8224 };
8225
8226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo___str__",kwnames,&obj0)) goto fail;
8227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8228 if (SWIG_arg_fail(1)) SWIG_fail;
8229 {
8230 PyThreadState* __tstate = wxPyBeginAllowThreads();
8231 result = wxNativeFontInfo___str__(arg1);
8232
8233 wxPyEndAllowThreads(__tstate);
8234 if (PyErr_Occurred()) SWIG_fail;
8235 }
8236 {
8237 #if wxUSE_UNICODE
8238 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8239 #else
8240 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8241 #endif
8242 }
8243 return resultobj;
8244 fail:
8245 return NULL;
8246 }
8247
8248
8249 static PyObject *_wrap_NativeFontInfo_FromUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8250 PyObject *resultobj;
8251 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8252 wxString *arg2 = 0 ;
8253 bool result;
8254 bool temp2 = false ;
8255 PyObject * obj0 = 0 ;
8256 PyObject * obj1 = 0 ;
8257 char *kwnames[] = {
8258 (char *) "self",(char *) "s", NULL
8259 };
8260
8261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromUserString",kwnames,&obj0,&obj1)) goto fail;
8262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8263 if (SWIG_arg_fail(1)) SWIG_fail;
8264 {
8265 arg2 = wxString_in_helper(obj1);
8266 if (arg2 == NULL) SWIG_fail;
8267 temp2 = true;
8268 }
8269 {
8270 PyThreadState* __tstate = wxPyBeginAllowThreads();
8271 result = (bool)(arg1)->FromUserString((wxString const &)*arg2);
8272
8273 wxPyEndAllowThreads(__tstate);
8274 if (PyErr_Occurred()) SWIG_fail;
8275 }
8276 {
8277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8278 }
8279 {
8280 if (temp2)
8281 delete arg2;
8282 }
8283 return resultobj;
8284 fail:
8285 {
8286 if (temp2)
8287 delete arg2;
8288 }
8289 return NULL;
8290 }
8291
8292
8293 static PyObject *_wrap_NativeFontInfo_ToUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8294 PyObject *resultobj;
8295 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8296 wxString result;
8297 PyObject * obj0 = 0 ;
8298 char *kwnames[] = {
8299 (char *) "self", NULL
8300 };
8301
8302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToUserString",kwnames,&obj0)) goto fail;
8303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8304 if (SWIG_arg_fail(1)) SWIG_fail;
8305 {
8306 PyThreadState* __tstate = wxPyBeginAllowThreads();
8307 result = ((wxNativeFontInfo const *)arg1)->ToUserString();
8308
8309 wxPyEndAllowThreads(__tstate);
8310 if (PyErr_Occurred()) SWIG_fail;
8311 }
8312 {
8313 #if wxUSE_UNICODE
8314 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8315 #else
8316 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8317 #endif
8318 }
8319 return resultobj;
8320 fail:
8321 return NULL;
8322 }
8323
8324
8325 static PyObject * NativeFontInfo_swigregister(PyObject *, PyObject *args) {
8326 PyObject *obj;
8327 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8328 SWIG_TypeClientData(SWIGTYPE_p_wxNativeFontInfo, obj);
8329 Py_INCREF(obj);
8330 return Py_BuildValue((char *)"");
8331 }
8332 static PyObject *_wrap_NativeEncodingInfo_facename_set(PyObject *, PyObject *args, PyObject *kwargs) {
8333 PyObject *resultobj;
8334 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8335 wxString *arg2 = (wxString *) 0 ;
8336 bool temp2 = false ;
8337 PyObject * obj0 = 0 ;
8338 PyObject * obj1 = 0 ;
8339 char *kwnames[] = {
8340 (char *) "self",(char *) "facename", NULL
8341 };
8342
8343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_facename_set",kwnames,&obj0,&obj1)) goto fail;
8344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8345 if (SWIG_arg_fail(1)) SWIG_fail;
8346 {
8347 arg2 = wxString_in_helper(obj1);
8348 if (arg2 == NULL) SWIG_fail;
8349 temp2 = true;
8350 }
8351 if (arg1) (arg1)->facename = *arg2;
8352
8353 Py_INCREF(Py_None); resultobj = Py_None;
8354 {
8355 if (temp2)
8356 delete arg2;
8357 }
8358 return resultobj;
8359 fail:
8360 {
8361 if (temp2)
8362 delete arg2;
8363 }
8364 return NULL;
8365 }
8366
8367
8368 static PyObject *_wrap_NativeEncodingInfo_facename_get(PyObject *, PyObject *args, PyObject *kwargs) {
8369 PyObject *resultobj;
8370 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8371 wxString *result;
8372 PyObject * obj0 = 0 ;
8373 char *kwnames[] = {
8374 (char *) "self", NULL
8375 };
8376
8377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_facename_get",kwnames,&obj0)) goto fail;
8378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8379 if (SWIG_arg_fail(1)) SWIG_fail;
8380 result = (wxString *)& ((arg1)->facename);
8381
8382 {
8383 #if wxUSE_UNICODE
8384 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8385 #else
8386 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8387 #endif
8388 }
8389 return resultobj;
8390 fail:
8391 return NULL;
8392 }
8393
8394
8395 static PyObject *_wrap_NativeEncodingInfo_encoding_set(PyObject *, PyObject *args, PyObject *kwargs) {
8396 PyObject *resultobj;
8397 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8398 wxFontEncoding arg2 ;
8399 PyObject * obj0 = 0 ;
8400 PyObject * obj1 = 0 ;
8401 char *kwnames[] = {
8402 (char *) "self",(char *) "encoding", NULL
8403 };
8404
8405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_encoding_set",kwnames,&obj0,&obj1)) goto fail;
8406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8407 if (SWIG_arg_fail(1)) SWIG_fail;
8408 {
8409 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8410 if (SWIG_arg_fail(2)) SWIG_fail;
8411 }
8412 if (arg1) (arg1)->encoding = (wxFontEncoding )arg2;
8413
8414 Py_INCREF(Py_None); resultobj = Py_None;
8415 return resultobj;
8416 fail:
8417 return NULL;
8418 }
8419
8420
8421 static PyObject *_wrap_NativeEncodingInfo_encoding_get(PyObject *, PyObject *args, PyObject *kwargs) {
8422 PyObject *resultobj;
8423 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8424 wxFontEncoding result;
8425 PyObject * obj0 = 0 ;
8426 char *kwnames[] = {
8427 (char *) "self", NULL
8428 };
8429
8430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_encoding_get",kwnames,&obj0)) goto fail;
8431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8432 if (SWIG_arg_fail(1)) SWIG_fail;
8433 result = (wxFontEncoding) ((arg1)->encoding);
8434
8435 resultobj = SWIG_From_int((result));
8436 return resultobj;
8437 fail:
8438 return NULL;
8439 }
8440
8441
8442 static PyObject *_wrap_new_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8443 PyObject *resultobj;
8444 wxNativeEncodingInfo *result;
8445 char *kwnames[] = {
8446 NULL
8447 };
8448
8449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeEncodingInfo",kwnames)) goto fail;
8450 {
8451 PyThreadState* __tstate = wxPyBeginAllowThreads();
8452 result = (wxNativeEncodingInfo *)new wxNativeEncodingInfo();
8453
8454 wxPyEndAllowThreads(__tstate);
8455 if (PyErr_Occurred()) SWIG_fail;
8456 }
8457 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 1);
8458 return resultobj;
8459 fail:
8460 return NULL;
8461 }
8462
8463
8464 static PyObject *_wrap_delete_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8465 PyObject *resultobj;
8466 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8467 PyObject * obj0 = 0 ;
8468 char *kwnames[] = {
8469 (char *) "self", NULL
8470 };
8471
8472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeEncodingInfo",kwnames,&obj0)) goto fail;
8473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8474 if (SWIG_arg_fail(1)) SWIG_fail;
8475 {
8476 PyThreadState* __tstate = wxPyBeginAllowThreads();
8477 delete arg1;
8478
8479 wxPyEndAllowThreads(__tstate);
8480 if (PyErr_Occurred()) SWIG_fail;
8481 }
8482 Py_INCREF(Py_None); resultobj = Py_None;
8483 return resultobj;
8484 fail:
8485 return NULL;
8486 }
8487
8488
8489 static PyObject *_wrap_NativeEncodingInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8490 PyObject *resultobj;
8491 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8492 wxString *arg2 = 0 ;
8493 bool result;
8494 bool temp2 = false ;
8495 PyObject * obj0 = 0 ;
8496 PyObject * obj1 = 0 ;
8497 char *kwnames[] = {
8498 (char *) "self",(char *) "s", NULL
8499 };
8500
8501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8503 if (SWIG_arg_fail(1)) SWIG_fail;
8504 {
8505 arg2 = wxString_in_helper(obj1);
8506 if (arg2 == NULL) SWIG_fail;
8507 temp2 = true;
8508 }
8509 {
8510 PyThreadState* __tstate = wxPyBeginAllowThreads();
8511 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8512
8513 wxPyEndAllowThreads(__tstate);
8514 if (PyErr_Occurred()) SWIG_fail;
8515 }
8516 {
8517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8518 }
8519 {
8520 if (temp2)
8521 delete arg2;
8522 }
8523 return resultobj;
8524 fail:
8525 {
8526 if (temp2)
8527 delete arg2;
8528 }
8529 return NULL;
8530 }
8531
8532
8533 static PyObject *_wrap_NativeEncodingInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8534 PyObject *resultobj;
8535 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8536 wxString result;
8537 PyObject * obj0 = 0 ;
8538 char *kwnames[] = {
8539 (char *) "self", NULL
8540 };
8541
8542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_ToString",kwnames,&obj0)) goto fail;
8543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8544 if (SWIG_arg_fail(1)) SWIG_fail;
8545 {
8546 PyThreadState* __tstate = wxPyBeginAllowThreads();
8547 result = ((wxNativeEncodingInfo const *)arg1)->ToString();
8548
8549 wxPyEndAllowThreads(__tstate);
8550 if (PyErr_Occurred()) SWIG_fail;
8551 }
8552 {
8553 #if wxUSE_UNICODE
8554 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8555 #else
8556 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8557 #endif
8558 }
8559 return resultobj;
8560 fail:
8561 return NULL;
8562 }
8563
8564
8565 static PyObject * NativeEncodingInfo_swigregister(PyObject *, PyObject *args) {
8566 PyObject *obj;
8567 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8568 SWIG_TypeClientData(SWIGTYPE_p_wxNativeEncodingInfo, obj);
8569 Py_INCREF(obj);
8570 return Py_BuildValue((char *)"");
8571 }
8572 static PyObject *_wrap_GetNativeFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8573 PyObject *resultobj;
8574 wxFontEncoding arg1 ;
8575 wxNativeEncodingInfo *result;
8576 PyObject * obj0 = 0 ;
8577 char *kwnames[] = {
8578 (char *) "encoding", NULL
8579 };
8580
8581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetNativeFontEncoding",kwnames,&obj0)) goto fail;
8582 {
8583 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8584 if (SWIG_arg_fail(1)) SWIG_fail;
8585 }
8586 {
8587 PyThreadState* __tstate = wxPyBeginAllowThreads();
8588 result = (wxNativeEncodingInfo *)wxGetNativeFontEncoding((wxFontEncoding )arg1);
8589
8590 wxPyEndAllowThreads(__tstate);
8591 if (PyErr_Occurred()) SWIG_fail;
8592 }
8593 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 0);
8594 return resultobj;
8595 fail:
8596 return NULL;
8597 }
8598
8599
8600 static PyObject *_wrap_TestFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8601 PyObject *resultobj;
8602 wxNativeEncodingInfo *arg1 = 0 ;
8603 bool result;
8604 PyObject * obj0 = 0 ;
8605 char *kwnames[] = {
8606 (char *) "info", NULL
8607 };
8608
8609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TestFontEncoding",kwnames,&obj0)) goto fail;
8610 {
8611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8612 if (SWIG_arg_fail(1)) SWIG_fail;
8613 if (arg1 == NULL) {
8614 SWIG_null_ref("wxNativeEncodingInfo");
8615 }
8616 if (SWIG_arg_fail(1)) SWIG_fail;
8617 }
8618 {
8619 PyThreadState* __tstate = wxPyBeginAllowThreads();
8620 result = (bool)wxTestFontEncoding((wxNativeEncodingInfo const &)*arg1);
8621
8622 wxPyEndAllowThreads(__tstate);
8623 if (PyErr_Occurred()) SWIG_fail;
8624 }
8625 {
8626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8627 }
8628 return resultobj;
8629 fail:
8630 return NULL;
8631 }
8632
8633
8634 static PyObject *_wrap_new_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
8635 PyObject *resultobj;
8636 wxFontMapper *result;
8637 char *kwnames[] = {
8638 NULL
8639 };
8640
8641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontMapper",kwnames)) goto fail;
8642 {
8643 PyThreadState* __tstate = wxPyBeginAllowThreads();
8644 result = (wxFontMapper *)new wxFontMapper();
8645
8646 wxPyEndAllowThreads(__tstate);
8647 if (PyErr_Occurred()) SWIG_fail;
8648 }
8649 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 1);
8650 return resultobj;
8651 fail:
8652 return NULL;
8653 }
8654
8655
8656 static PyObject *_wrap_delete_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
8657 PyObject *resultobj;
8658 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8659 PyObject * obj0 = 0 ;
8660 char *kwnames[] = {
8661 (char *) "self", NULL
8662 };
8663
8664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontMapper",kwnames,&obj0)) goto fail;
8665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8666 if (SWIG_arg_fail(1)) SWIG_fail;
8667 {
8668 PyThreadState* __tstate = wxPyBeginAllowThreads();
8669 delete arg1;
8670
8671 wxPyEndAllowThreads(__tstate);
8672 if (PyErr_Occurred()) SWIG_fail;
8673 }
8674 Py_INCREF(Py_None); resultobj = Py_None;
8675 return resultobj;
8676 fail:
8677 return NULL;
8678 }
8679
8680
8681 static PyObject *_wrap_FontMapper_Get(PyObject *, PyObject *args, PyObject *kwargs) {
8682 PyObject *resultobj;
8683 wxFontMapper *result;
8684 char *kwnames[] = {
8685 NULL
8686 };
8687
8688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_Get",kwnames)) goto fail;
8689 {
8690 PyThreadState* __tstate = wxPyBeginAllowThreads();
8691 result = (wxFontMapper *)wxFontMapper::Get();
8692
8693 wxPyEndAllowThreads(__tstate);
8694 if (PyErr_Occurred()) SWIG_fail;
8695 }
8696 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
8697 return resultobj;
8698 fail:
8699 return NULL;
8700 }
8701
8702
8703 static PyObject *_wrap_FontMapper_Set(PyObject *, PyObject *args, PyObject *kwargs) {
8704 PyObject *resultobj;
8705 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8706 wxFontMapper *result;
8707 PyObject * obj0 = 0 ;
8708 char *kwnames[] = {
8709 (char *) "mapper", NULL
8710 };
8711
8712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_Set",kwnames,&obj0)) goto fail;
8713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8714 if (SWIG_arg_fail(1)) SWIG_fail;
8715 {
8716 PyThreadState* __tstate = wxPyBeginAllowThreads();
8717 result = (wxFontMapper *)wxFontMapper::Set(arg1);
8718
8719 wxPyEndAllowThreads(__tstate);
8720 if (PyErr_Occurred()) SWIG_fail;
8721 }
8722 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
8723 return resultobj;
8724 fail:
8725 return NULL;
8726 }
8727
8728
8729 static PyObject *_wrap_FontMapper_CharsetToEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8730 PyObject *resultobj;
8731 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8732 wxString *arg2 = 0 ;
8733 bool arg3 = (bool) true ;
8734 wxFontEncoding result;
8735 bool temp2 = false ;
8736 PyObject * obj0 = 0 ;
8737 PyObject * obj1 = 0 ;
8738 PyObject * obj2 = 0 ;
8739 char *kwnames[] = {
8740 (char *) "self",(char *) "charset",(char *) "interactive", NULL
8741 };
8742
8743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_CharsetToEncoding",kwnames,&obj0,&obj1,&obj2)) goto fail;
8744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8745 if (SWIG_arg_fail(1)) SWIG_fail;
8746 {
8747 arg2 = wxString_in_helper(obj1);
8748 if (arg2 == NULL) SWIG_fail;
8749 temp2 = true;
8750 }
8751 if (obj2) {
8752 {
8753 arg3 = (bool)(SWIG_As_bool(obj2));
8754 if (SWIG_arg_fail(3)) SWIG_fail;
8755 }
8756 }
8757 {
8758 PyThreadState* __tstate = wxPyBeginAllowThreads();
8759 result = (wxFontEncoding)(arg1)->CharsetToEncoding((wxString const &)*arg2,arg3);
8760
8761 wxPyEndAllowThreads(__tstate);
8762 if (PyErr_Occurred()) SWIG_fail;
8763 }
8764 resultobj = SWIG_From_int((result));
8765 {
8766 if (temp2)
8767 delete arg2;
8768 }
8769 return resultobj;
8770 fail:
8771 {
8772 if (temp2)
8773 delete arg2;
8774 }
8775 return NULL;
8776 }
8777
8778
8779 static PyObject *_wrap_FontMapper_GetSupportedEncodingsCount(PyObject *, PyObject *args, PyObject *kwargs) {
8780 PyObject *resultobj;
8781 size_t result;
8782 char *kwnames[] = {
8783 NULL
8784 };
8785
8786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetSupportedEncodingsCount",kwnames)) goto fail;
8787 {
8788 PyThreadState* __tstate = wxPyBeginAllowThreads();
8789 result = (size_t)wxFontMapper::GetSupportedEncodingsCount();
8790
8791 wxPyEndAllowThreads(__tstate);
8792 if (PyErr_Occurred()) SWIG_fail;
8793 }
8794 {
8795 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
8796 }
8797 return resultobj;
8798 fail:
8799 return NULL;
8800 }
8801
8802
8803 static PyObject *_wrap_FontMapper_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8804 PyObject *resultobj;
8805 size_t arg1 ;
8806 wxFontEncoding result;
8807 PyObject * obj0 = 0 ;
8808 char *kwnames[] = {
8809 (char *) "n", NULL
8810 };
8811
8812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncoding",kwnames,&obj0)) goto fail;
8813 {
8814 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8815 if (SWIG_arg_fail(1)) SWIG_fail;
8816 }
8817 {
8818 PyThreadState* __tstate = wxPyBeginAllowThreads();
8819 result = (wxFontEncoding)wxFontMapper::GetEncoding(arg1);
8820
8821 wxPyEndAllowThreads(__tstate);
8822 if (PyErr_Occurred()) SWIG_fail;
8823 }
8824 resultobj = SWIG_From_int((result));
8825 return resultobj;
8826 fail:
8827 return NULL;
8828 }
8829
8830
8831 static PyObject *_wrap_FontMapper_GetEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
8832 PyObject *resultobj;
8833 wxFontEncoding arg1 ;
8834 wxString result;
8835 PyObject * obj0 = 0 ;
8836 char *kwnames[] = {
8837 (char *) "encoding", NULL
8838 };
8839
8840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingName",kwnames,&obj0)) goto fail;
8841 {
8842 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8843 if (SWIG_arg_fail(1)) SWIG_fail;
8844 }
8845 {
8846 PyThreadState* __tstate = wxPyBeginAllowThreads();
8847 result = wxFontMapper::GetEncodingName((wxFontEncoding )arg1);
8848
8849 wxPyEndAllowThreads(__tstate);
8850 if (PyErr_Occurred()) SWIG_fail;
8851 }
8852 {
8853 #if wxUSE_UNICODE
8854 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8855 #else
8856 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8857 #endif
8858 }
8859 return resultobj;
8860 fail:
8861 return NULL;
8862 }
8863
8864
8865 static PyObject *_wrap_FontMapper_GetEncodingDescription(PyObject *, PyObject *args, PyObject *kwargs) {
8866 PyObject *resultobj;
8867 wxFontEncoding arg1 ;
8868 wxString result;
8869 PyObject * obj0 = 0 ;
8870 char *kwnames[] = {
8871 (char *) "encoding", NULL
8872 };
8873
8874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingDescription",kwnames,&obj0)) goto fail;
8875 {
8876 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8877 if (SWIG_arg_fail(1)) SWIG_fail;
8878 }
8879 {
8880 PyThreadState* __tstate = wxPyBeginAllowThreads();
8881 result = wxFontMapper::GetEncodingDescription((wxFontEncoding )arg1);
8882
8883 wxPyEndAllowThreads(__tstate);
8884 if (PyErr_Occurred()) SWIG_fail;
8885 }
8886 {
8887 #if wxUSE_UNICODE
8888 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8889 #else
8890 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8891 #endif
8892 }
8893 return resultobj;
8894 fail:
8895 return NULL;
8896 }
8897
8898
8899 static PyObject *_wrap_FontMapper_GetEncodingFromName(PyObject *, PyObject *args, PyObject *kwargs) {
8900 PyObject *resultobj;
8901 wxString *arg1 = 0 ;
8902 wxFontEncoding result;
8903 bool temp1 = false ;
8904 PyObject * obj0 = 0 ;
8905 char *kwnames[] = {
8906 (char *) "name", NULL
8907 };
8908
8909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingFromName",kwnames,&obj0)) goto fail;
8910 {
8911 arg1 = wxString_in_helper(obj0);
8912 if (arg1 == NULL) SWIG_fail;
8913 temp1 = true;
8914 }
8915 {
8916 PyThreadState* __tstate = wxPyBeginAllowThreads();
8917 result = (wxFontEncoding)wxFontMapper::GetEncodingFromName((wxString const &)*arg1);
8918
8919 wxPyEndAllowThreads(__tstate);
8920 if (PyErr_Occurred()) SWIG_fail;
8921 }
8922 resultobj = SWIG_From_int((result));
8923 {
8924 if (temp1)
8925 delete arg1;
8926 }
8927 return resultobj;
8928 fail:
8929 {
8930 if (temp1)
8931 delete arg1;
8932 }
8933 return NULL;
8934 }
8935
8936
8937 static PyObject *_wrap_FontMapper_SetConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
8938 PyObject *resultobj;
8939 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8940 wxString *arg2 = 0 ;
8941 bool temp2 = false ;
8942 PyObject * obj0 = 0 ;
8943 PyObject * obj1 = 0 ;
8944 char *kwnames[] = {
8945 (char *) "self",(char *) "prefix", NULL
8946 };
8947
8948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfigPath",kwnames,&obj0,&obj1)) goto fail;
8949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8950 if (SWIG_arg_fail(1)) SWIG_fail;
8951 {
8952 arg2 = wxString_in_helper(obj1);
8953 if (arg2 == NULL) SWIG_fail;
8954 temp2 = true;
8955 }
8956 {
8957 PyThreadState* __tstate = wxPyBeginAllowThreads();
8958 (arg1)->SetConfigPath((wxString const &)*arg2);
8959
8960 wxPyEndAllowThreads(__tstate);
8961 if (PyErr_Occurred()) SWIG_fail;
8962 }
8963 Py_INCREF(Py_None); resultobj = Py_None;
8964 {
8965 if (temp2)
8966 delete arg2;
8967 }
8968 return resultobj;
8969 fail:
8970 {
8971 if (temp2)
8972 delete arg2;
8973 }
8974 return NULL;
8975 }
8976
8977
8978 static PyObject *_wrap_FontMapper_GetDefaultConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
8979 PyObject *resultobj;
8980 wxString result;
8981 char *kwnames[] = {
8982 NULL
8983 };
8984
8985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetDefaultConfigPath",kwnames)) goto fail;
8986 {
8987 PyThreadState* __tstate = wxPyBeginAllowThreads();
8988 result = wxFontMapper::GetDefaultConfigPath();
8989
8990 wxPyEndAllowThreads(__tstate);
8991 if (PyErr_Occurred()) SWIG_fail;
8992 }
8993 {
8994 #if wxUSE_UNICODE
8995 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8996 #else
8997 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8998 #endif
8999 }
9000 return resultobj;
9001 fail:
9002 return NULL;
9003 }
9004
9005
9006 static PyObject *_wrap_FontMapper_GetAltForEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9007 PyObject *resultobj;
9008 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9009 wxFontEncoding arg2 ;
9010 wxString const &arg3_defvalue = wxPyEmptyString ;
9011 wxString *arg3 = (wxString *) &arg3_defvalue ;
9012 bool arg4 = (bool) true ;
9013 PyObject *result;
9014 bool temp3 = false ;
9015 PyObject * obj0 = 0 ;
9016 PyObject * obj1 = 0 ;
9017 PyObject * obj2 = 0 ;
9018 PyObject * obj3 = 0 ;
9019 char *kwnames[] = {
9020 (char *) "self",(char *) "encoding",(char *) "facename",(char *) "interactive", NULL
9021 };
9022
9023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:FontMapper_GetAltForEncoding",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9025 if (SWIG_arg_fail(1)) SWIG_fail;
9026 {
9027 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9028 if (SWIG_arg_fail(2)) SWIG_fail;
9029 }
9030 if (obj2) {
9031 {
9032 arg3 = wxString_in_helper(obj2);
9033 if (arg3 == NULL) SWIG_fail;
9034 temp3 = true;
9035 }
9036 }
9037 if (obj3) {
9038 {
9039 arg4 = (bool)(SWIG_As_bool(obj3));
9040 if (SWIG_arg_fail(4)) SWIG_fail;
9041 }
9042 }
9043 {
9044 PyThreadState* __tstate = wxPyBeginAllowThreads();
9045 result = (PyObject *)wxFontMapper_GetAltForEncoding(arg1,(wxFontEncoding )arg2,(wxString const &)*arg3,arg4);
9046
9047 wxPyEndAllowThreads(__tstate);
9048 if (PyErr_Occurred()) SWIG_fail;
9049 }
9050 resultobj = result;
9051 {
9052 if (temp3)
9053 delete arg3;
9054 }
9055 return resultobj;
9056 fail:
9057 {
9058 if (temp3)
9059 delete arg3;
9060 }
9061 return NULL;
9062 }
9063
9064
9065 static PyObject *_wrap_FontMapper_IsEncodingAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
9066 PyObject *resultobj;
9067 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9068 wxFontEncoding arg2 ;
9069 wxString const &arg3_defvalue = wxPyEmptyString ;
9070 wxString *arg3 = (wxString *) &arg3_defvalue ;
9071 bool result;
9072 bool temp3 = false ;
9073 PyObject * obj0 = 0 ;
9074 PyObject * obj1 = 0 ;
9075 PyObject * obj2 = 0 ;
9076 char *kwnames[] = {
9077 (char *) "self",(char *) "encoding",(char *) "facename", NULL
9078 };
9079
9080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_IsEncodingAvailable",kwnames,&obj0,&obj1,&obj2)) goto fail;
9081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9082 if (SWIG_arg_fail(1)) SWIG_fail;
9083 {
9084 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9085 if (SWIG_arg_fail(2)) SWIG_fail;
9086 }
9087 if (obj2) {
9088 {
9089 arg3 = wxString_in_helper(obj2);
9090 if (arg3 == NULL) SWIG_fail;
9091 temp3 = true;
9092 }
9093 }
9094 {
9095 PyThreadState* __tstate = wxPyBeginAllowThreads();
9096 result = (bool)(arg1)->IsEncodingAvailable((wxFontEncoding )arg2,(wxString const &)*arg3);
9097
9098 wxPyEndAllowThreads(__tstate);
9099 if (PyErr_Occurred()) SWIG_fail;
9100 }
9101 {
9102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9103 }
9104 {
9105 if (temp3)
9106 delete arg3;
9107 }
9108 return resultobj;
9109 fail:
9110 {
9111 if (temp3)
9112 delete arg3;
9113 }
9114 return NULL;
9115 }
9116
9117
9118 static PyObject *_wrap_FontMapper_SetDialogParent(PyObject *, PyObject *args, PyObject *kwargs) {
9119 PyObject *resultobj;
9120 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9121 wxWindow *arg2 = (wxWindow *) 0 ;
9122 PyObject * obj0 = 0 ;
9123 PyObject * obj1 = 0 ;
9124 char *kwnames[] = {
9125 (char *) "self",(char *) "parent", NULL
9126 };
9127
9128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogParent",kwnames,&obj0,&obj1)) goto fail;
9129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9130 if (SWIG_arg_fail(1)) SWIG_fail;
9131 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9132 if (SWIG_arg_fail(2)) SWIG_fail;
9133 {
9134 PyThreadState* __tstate = wxPyBeginAllowThreads();
9135 (arg1)->SetDialogParent(arg2);
9136
9137 wxPyEndAllowThreads(__tstate);
9138 if (PyErr_Occurred()) SWIG_fail;
9139 }
9140 Py_INCREF(Py_None); resultobj = Py_None;
9141 return resultobj;
9142 fail:
9143 return NULL;
9144 }
9145
9146
9147 static PyObject *_wrap_FontMapper_SetDialogTitle(PyObject *, PyObject *args, PyObject *kwargs) {
9148 PyObject *resultobj;
9149 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9150 wxString *arg2 = 0 ;
9151 bool temp2 = false ;
9152 PyObject * obj0 = 0 ;
9153 PyObject * obj1 = 0 ;
9154 char *kwnames[] = {
9155 (char *) "self",(char *) "title", NULL
9156 };
9157
9158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogTitle",kwnames,&obj0,&obj1)) goto fail;
9159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9160 if (SWIG_arg_fail(1)) SWIG_fail;
9161 {
9162 arg2 = wxString_in_helper(obj1);
9163 if (arg2 == NULL) SWIG_fail;
9164 temp2 = true;
9165 }
9166 {
9167 PyThreadState* __tstate = wxPyBeginAllowThreads();
9168 (arg1)->SetDialogTitle((wxString const &)*arg2);
9169
9170 wxPyEndAllowThreads(__tstate);
9171 if (PyErr_Occurred()) SWIG_fail;
9172 }
9173 Py_INCREF(Py_None); resultobj = Py_None;
9174 {
9175 if (temp2)
9176 delete arg2;
9177 }
9178 return resultobj;
9179 fail:
9180 {
9181 if (temp2)
9182 delete arg2;
9183 }
9184 return NULL;
9185 }
9186
9187
9188 static PyObject * FontMapper_swigregister(PyObject *, PyObject *args) {
9189 PyObject *obj;
9190 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9191 SWIG_TypeClientData(SWIGTYPE_p_wxFontMapper, obj);
9192 Py_INCREF(obj);
9193 return Py_BuildValue((char *)"");
9194 }
9195 static PyObject *_wrap_new_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9196 PyObject *resultobj;
9197 int arg1 ;
9198 int arg2 ;
9199 int arg3 ;
9200 int arg4 ;
9201 bool arg5 = (bool) false ;
9202 wxString const &arg6_defvalue = wxPyEmptyString ;
9203 wxString *arg6 = (wxString *) &arg6_defvalue ;
9204 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9205 wxFont *result;
9206 bool temp6 = false ;
9207 PyObject * obj0 = 0 ;
9208 PyObject * obj1 = 0 ;
9209 PyObject * obj2 = 0 ;
9210 PyObject * obj3 = 0 ;
9211 PyObject * obj4 = 0 ;
9212 PyObject * obj5 = 0 ;
9213 PyObject * obj6 = 0 ;
9214 char *kwnames[] = {
9215 (char *) "pointSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "face",(char *) "encoding", NULL
9216 };
9217
9218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_Font",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9219 {
9220 arg1 = (int)(SWIG_As_int(obj0));
9221 if (SWIG_arg_fail(1)) SWIG_fail;
9222 }
9223 {
9224 arg2 = (int)(SWIG_As_int(obj1));
9225 if (SWIG_arg_fail(2)) SWIG_fail;
9226 }
9227 {
9228 arg3 = (int)(SWIG_As_int(obj2));
9229 if (SWIG_arg_fail(3)) SWIG_fail;
9230 }
9231 {
9232 arg4 = (int)(SWIG_As_int(obj3));
9233 if (SWIG_arg_fail(4)) SWIG_fail;
9234 }
9235 if (obj4) {
9236 {
9237 arg5 = (bool)(SWIG_As_bool(obj4));
9238 if (SWIG_arg_fail(5)) SWIG_fail;
9239 }
9240 }
9241 if (obj5) {
9242 {
9243 arg6 = wxString_in_helper(obj5);
9244 if (arg6 == NULL) SWIG_fail;
9245 temp6 = true;
9246 }
9247 }
9248 if (obj6) {
9249 {
9250 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9251 if (SWIG_arg_fail(7)) SWIG_fail;
9252 }
9253 }
9254 {
9255 if (!wxPyCheckForApp()) SWIG_fail;
9256 PyThreadState* __tstate = wxPyBeginAllowThreads();
9257 result = (wxFont *)new wxFont(arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9258
9259 wxPyEndAllowThreads(__tstate);
9260 if (PyErr_Occurred()) SWIG_fail;
9261 }
9262 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9263 {
9264 if (temp6)
9265 delete arg6;
9266 }
9267 return resultobj;
9268 fail:
9269 {
9270 if (temp6)
9271 delete arg6;
9272 }
9273 return NULL;
9274 }
9275
9276
9277 static PyObject *_wrap_delete_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9278 PyObject *resultobj;
9279 wxFont *arg1 = (wxFont *) 0 ;
9280 PyObject * obj0 = 0 ;
9281 char *kwnames[] = {
9282 (char *) "self", NULL
9283 };
9284
9285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Font",kwnames,&obj0)) goto fail;
9286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9287 if (SWIG_arg_fail(1)) SWIG_fail;
9288 {
9289 PyThreadState* __tstate = wxPyBeginAllowThreads();
9290 delete arg1;
9291
9292 wxPyEndAllowThreads(__tstate);
9293 if (PyErr_Occurred()) SWIG_fail;
9294 }
9295 Py_INCREF(Py_None); resultobj = Py_None;
9296 return resultobj;
9297 fail:
9298 return NULL;
9299 }
9300
9301
9302 static PyObject *_wrap_new_FontFromNativeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9303 PyObject *resultobj;
9304 wxNativeFontInfo *arg1 = 0 ;
9305 wxFont *result;
9306 PyObject * obj0 = 0 ;
9307 char *kwnames[] = {
9308 (char *) "info", NULL
9309 };
9310
9311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfo",kwnames,&obj0)) goto fail;
9312 {
9313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
9314 if (SWIG_arg_fail(1)) SWIG_fail;
9315 if (arg1 == NULL) {
9316 SWIG_null_ref("wxNativeFontInfo");
9317 }
9318 if (SWIG_arg_fail(1)) SWIG_fail;
9319 }
9320 {
9321 if (!wxPyCheckForApp()) SWIG_fail;
9322 PyThreadState* __tstate = wxPyBeginAllowThreads();
9323 result = (wxFont *)new wxFont((wxNativeFontInfo const &)*arg1);
9324
9325 wxPyEndAllowThreads(__tstate);
9326 if (PyErr_Occurred()) SWIG_fail;
9327 }
9328 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9329 return resultobj;
9330 fail:
9331 return NULL;
9332 }
9333
9334
9335 static PyObject *_wrap_new_FontFromNativeInfoString(PyObject *, PyObject *args, PyObject *kwargs) {
9336 PyObject *resultobj;
9337 wxString *arg1 = 0 ;
9338 wxFont *result;
9339 bool temp1 = false ;
9340 PyObject * obj0 = 0 ;
9341 char *kwnames[] = {
9342 (char *) "info", NULL
9343 };
9344
9345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfoString",kwnames,&obj0)) goto fail;
9346 {
9347 arg1 = wxString_in_helper(obj0);
9348 if (arg1 == NULL) SWIG_fail;
9349 temp1 = true;
9350 }
9351 {
9352 if (!wxPyCheckForApp()) SWIG_fail;
9353 PyThreadState* __tstate = wxPyBeginAllowThreads();
9354 result = (wxFont *)new_wxFont((wxString const &)*arg1);
9355
9356 wxPyEndAllowThreads(__tstate);
9357 if (PyErr_Occurred()) SWIG_fail;
9358 }
9359 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9360 {
9361 if (temp1)
9362 delete arg1;
9363 }
9364 return resultobj;
9365 fail:
9366 {
9367 if (temp1)
9368 delete arg1;
9369 }
9370 return NULL;
9371 }
9372
9373
9374 static PyObject *_wrap_new_FFont(PyObject *, PyObject *args, PyObject *kwargs) {
9375 PyObject *resultobj;
9376 int arg1 ;
9377 wxFontFamily arg2 ;
9378 int arg3 = (int) wxFONTFLAG_DEFAULT ;
9379 wxString const &arg4_defvalue = wxPyEmptyString ;
9380 wxString *arg4 = (wxString *) &arg4_defvalue ;
9381 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9382 wxFont *result;
9383 bool temp4 = false ;
9384 PyObject * obj0 = 0 ;
9385 PyObject * obj1 = 0 ;
9386 PyObject * obj2 = 0 ;
9387 PyObject * obj3 = 0 ;
9388 PyObject * obj4 = 0 ;
9389 char *kwnames[] = {
9390 (char *) "pointSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
9391 };
9392
9393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_FFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
9394 {
9395 arg1 = (int)(SWIG_As_int(obj0));
9396 if (SWIG_arg_fail(1)) SWIG_fail;
9397 }
9398 {
9399 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
9400 if (SWIG_arg_fail(2)) SWIG_fail;
9401 }
9402 if (obj2) {
9403 {
9404 arg3 = (int)(SWIG_As_int(obj2));
9405 if (SWIG_arg_fail(3)) SWIG_fail;
9406 }
9407 }
9408 if (obj3) {
9409 {
9410 arg4 = wxString_in_helper(obj3);
9411 if (arg4 == NULL) SWIG_fail;
9412 temp4 = true;
9413 }
9414 }
9415 if (obj4) {
9416 {
9417 arg5 = (wxFontEncoding)(SWIG_As_int(obj4));
9418 if (SWIG_arg_fail(5)) SWIG_fail;
9419 }
9420 }
9421 {
9422 if (!wxPyCheckForApp()) SWIG_fail;
9423 PyThreadState* __tstate = wxPyBeginAllowThreads();
9424 result = (wxFont *)new_wxFont(arg1,(wxFontFamily )arg2,arg3,(wxString const &)*arg4,(wxFontEncoding )arg5);
9425
9426 wxPyEndAllowThreads(__tstate);
9427 if (PyErr_Occurred()) SWIG_fail;
9428 }
9429 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9430 {
9431 if (temp4)
9432 delete arg4;
9433 }
9434 return resultobj;
9435 fail:
9436 {
9437 if (temp4)
9438 delete arg4;
9439 }
9440 return NULL;
9441 }
9442
9443
9444 static PyObject *_wrap_new_FontFromPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9445 PyObject *resultobj;
9446 wxSize *arg1 = 0 ;
9447 int arg2 ;
9448 int arg3 ;
9449 int arg4 ;
9450 bool arg5 = (bool) false ;
9451 wxString const &arg6_defvalue = wxEmptyString ;
9452 wxString *arg6 = (wxString *) &arg6_defvalue ;
9453 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9454 wxFont *result;
9455 wxSize temp1 ;
9456 bool temp6 = false ;
9457 PyObject * obj0 = 0 ;
9458 PyObject * obj1 = 0 ;
9459 PyObject * obj2 = 0 ;
9460 PyObject * obj3 = 0 ;
9461 PyObject * obj4 = 0 ;
9462 PyObject * obj5 = 0 ;
9463 PyObject * obj6 = 0 ;
9464 char *kwnames[] = {
9465 (char *) "pixelSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underlined",(char *) "face",(char *) "encoding", NULL
9466 };
9467
9468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_FontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9469 {
9470 arg1 = &temp1;
9471 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
9472 }
9473 {
9474 arg2 = (int)(SWIG_As_int(obj1));
9475 if (SWIG_arg_fail(2)) SWIG_fail;
9476 }
9477 {
9478 arg3 = (int)(SWIG_As_int(obj2));
9479 if (SWIG_arg_fail(3)) SWIG_fail;
9480 }
9481 {
9482 arg4 = (int)(SWIG_As_int(obj3));
9483 if (SWIG_arg_fail(4)) SWIG_fail;
9484 }
9485 if (obj4) {
9486 {
9487 arg5 = (bool)(SWIG_As_bool(obj4));
9488 if (SWIG_arg_fail(5)) SWIG_fail;
9489 }
9490 }
9491 if (obj5) {
9492 {
9493 arg6 = wxString_in_helper(obj5);
9494 if (arg6 == NULL) SWIG_fail;
9495 temp6 = true;
9496 }
9497 }
9498 if (obj6) {
9499 {
9500 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9501 if (SWIG_arg_fail(7)) SWIG_fail;
9502 }
9503 }
9504 {
9505 if (!wxPyCheckForApp()) SWIG_fail;
9506 PyThreadState* __tstate = wxPyBeginAllowThreads();
9507 result = (wxFont *)new_wxFont((wxSize const &)*arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9508
9509 wxPyEndAllowThreads(__tstate);
9510 if (PyErr_Occurred()) SWIG_fail;
9511 }
9512 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9513 {
9514 if (temp6)
9515 delete arg6;
9516 }
9517 return resultobj;
9518 fail:
9519 {
9520 if (temp6)
9521 delete arg6;
9522 }
9523 return NULL;
9524 }
9525
9526
9527 static PyObject *_wrap_new_FFontFromPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9528 PyObject *resultobj;
9529 wxSize *arg1 = 0 ;
9530 wxFontFamily arg2 ;
9531 int arg3 = (int) wxFONTFLAG_DEFAULT ;
9532 wxString const &arg4_defvalue = wxEmptyString ;
9533 wxString *arg4 = (wxString *) &arg4_defvalue ;
9534 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9535 wxFont *result;
9536 wxSize temp1 ;
9537 bool temp4 = false ;
9538 PyObject * obj0 = 0 ;
9539 PyObject * obj1 = 0 ;
9540 PyObject * obj2 = 0 ;
9541 PyObject * obj3 = 0 ;
9542 PyObject * obj4 = 0 ;
9543 char *kwnames[] = {
9544 (char *) "pixelSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
9545 };
9546
9547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_FFontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
9548 {
9549 arg1 = &temp1;
9550 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
9551 }
9552 {
9553 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
9554 if (SWIG_arg_fail(2)) SWIG_fail;
9555 }
9556 if (obj2) {
9557 {
9558 arg3 = (int)(SWIG_As_int(obj2));
9559 if (SWIG_arg_fail(3)) SWIG_fail;
9560 }
9561 }
9562 if (obj3) {
9563 {
9564 arg4 = wxString_in_helper(obj3);
9565 if (arg4 == NULL) SWIG_fail;
9566 temp4 = true;
9567 }
9568 }
9569 if (obj4) {
9570 {
9571 arg5 = (wxFontEncoding)(SWIG_As_int(obj4));
9572 if (SWIG_arg_fail(5)) SWIG_fail;
9573 }
9574 }
9575 {
9576 if (!wxPyCheckForApp()) SWIG_fail;
9577 PyThreadState* __tstate = wxPyBeginAllowThreads();
9578 result = (wxFont *)new_wxFont((wxSize const &)*arg1,(wxFontFamily )arg2,arg3,(wxString const &)*arg4,(wxFontEncoding )arg5);
9579
9580 wxPyEndAllowThreads(__tstate);
9581 if (PyErr_Occurred()) SWIG_fail;
9582 }
9583 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9584 {
9585 if (temp4)
9586 delete arg4;
9587 }
9588 return resultobj;
9589 fail:
9590 {
9591 if (temp4)
9592 delete arg4;
9593 }
9594 return NULL;
9595 }
9596
9597
9598 static PyObject *_wrap_Font_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
9599 PyObject *resultobj;
9600 wxFont *arg1 = (wxFont *) 0 ;
9601 bool result;
9602 PyObject * obj0 = 0 ;
9603 char *kwnames[] = {
9604 (char *) "self", NULL
9605 };
9606
9607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_Ok",kwnames,&obj0)) goto fail;
9608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9609 if (SWIG_arg_fail(1)) SWIG_fail;
9610 {
9611 PyThreadState* __tstate = wxPyBeginAllowThreads();
9612 result = (bool)((wxFont const *)arg1)->Ok();
9613
9614 wxPyEndAllowThreads(__tstate);
9615 if (PyErr_Occurred()) SWIG_fail;
9616 }
9617 {
9618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9619 }
9620 return resultobj;
9621 fail:
9622 return NULL;
9623 }
9624
9625
9626 static PyObject *_wrap_Font___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
9627 PyObject *resultobj;
9628 wxFont *arg1 = (wxFont *) 0 ;
9629 wxFont *arg2 = (wxFont *) 0 ;
9630 bool result;
9631 PyObject * obj0 = 0 ;
9632 PyObject * obj1 = 0 ;
9633 char *kwnames[] = {
9634 (char *) "self",(char *) "other", NULL
9635 };
9636
9637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___eq__",kwnames,&obj0,&obj1)) goto fail;
9638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9639 if (SWIG_arg_fail(1)) SWIG_fail;
9640 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9641 if (SWIG_arg_fail(2)) SWIG_fail;
9642 {
9643 PyThreadState* __tstate = wxPyBeginAllowThreads();
9644 result = (bool)wxFont___eq__(arg1,(wxFont const *)arg2);
9645
9646 wxPyEndAllowThreads(__tstate);
9647 if (PyErr_Occurred()) SWIG_fail;
9648 }
9649 {
9650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9651 }
9652 return resultobj;
9653 fail:
9654 return NULL;
9655 }
9656
9657
9658 static PyObject *_wrap_Font___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
9659 PyObject *resultobj;
9660 wxFont *arg1 = (wxFont *) 0 ;
9661 wxFont *arg2 = (wxFont *) 0 ;
9662 bool result;
9663 PyObject * obj0 = 0 ;
9664 PyObject * obj1 = 0 ;
9665 char *kwnames[] = {
9666 (char *) "self",(char *) "other", NULL
9667 };
9668
9669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___ne__",kwnames,&obj0,&obj1)) goto fail;
9670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9671 if (SWIG_arg_fail(1)) SWIG_fail;
9672 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9673 if (SWIG_arg_fail(2)) SWIG_fail;
9674 {
9675 PyThreadState* __tstate = wxPyBeginAllowThreads();
9676 result = (bool)wxFont___ne__(arg1,(wxFont const *)arg2);
9677
9678 wxPyEndAllowThreads(__tstate);
9679 if (PyErr_Occurred()) SWIG_fail;
9680 }
9681 {
9682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9683 }
9684 return resultobj;
9685 fail:
9686 return NULL;
9687 }
9688
9689
9690 static PyObject *_wrap_Font_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
9691 PyObject *resultobj;
9692 wxFont *arg1 = (wxFont *) 0 ;
9693 int result;
9694 PyObject * obj0 = 0 ;
9695 char *kwnames[] = {
9696 (char *) "self", NULL
9697 };
9698
9699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPointSize",kwnames,&obj0)) goto fail;
9700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9701 if (SWIG_arg_fail(1)) SWIG_fail;
9702 {
9703 PyThreadState* __tstate = wxPyBeginAllowThreads();
9704 result = (int)((wxFont const *)arg1)->GetPointSize();
9705
9706 wxPyEndAllowThreads(__tstate);
9707 if (PyErr_Occurred()) SWIG_fail;
9708 }
9709 {
9710 resultobj = SWIG_From_int((int)(result));
9711 }
9712 return resultobj;
9713 fail:
9714 return NULL;
9715 }
9716
9717
9718 static PyObject *_wrap_Font_GetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9719 PyObject *resultobj;
9720 wxFont *arg1 = (wxFont *) 0 ;
9721 wxSize result;
9722 PyObject * obj0 = 0 ;
9723 char *kwnames[] = {
9724 (char *) "self", NULL
9725 };
9726
9727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPixelSize",kwnames,&obj0)) goto fail;
9728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9729 if (SWIG_arg_fail(1)) SWIG_fail;
9730 {
9731 PyThreadState* __tstate = wxPyBeginAllowThreads();
9732 result = ((wxFont const *)arg1)->GetPixelSize();
9733
9734 wxPyEndAllowThreads(__tstate);
9735 if (PyErr_Occurred()) SWIG_fail;
9736 }
9737 {
9738 wxSize * resultptr;
9739 resultptr = new wxSize((wxSize &)(result));
9740 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
9741 }
9742 return resultobj;
9743 fail:
9744 return NULL;
9745 }
9746
9747
9748 static PyObject *_wrap_Font_IsUsingSizeInPixels(PyObject *, PyObject *args, PyObject *kwargs) {
9749 PyObject *resultobj;
9750 wxFont *arg1 = (wxFont *) 0 ;
9751 bool result;
9752 PyObject * obj0 = 0 ;
9753 char *kwnames[] = {
9754 (char *) "self", NULL
9755 };
9756
9757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsUsingSizeInPixels",kwnames,&obj0)) goto fail;
9758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9759 if (SWIG_arg_fail(1)) SWIG_fail;
9760 {
9761 PyThreadState* __tstate = wxPyBeginAllowThreads();
9762 result = (bool)((wxFont const *)arg1)->IsUsingSizeInPixels();
9763
9764 wxPyEndAllowThreads(__tstate);
9765 if (PyErr_Occurred()) SWIG_fail;
9766 }
9767 {
9768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9769 }
9770 return resultobj;
9771 fail:
9772 return NULL;
9773 }
9774
9775
9776 static PyObject *_wrap_Font_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
9777 PyObject *resultobj;
9778 wxFont *arg1 = (wxFont *) 0 ;
9779 int result;
9780 PyObject * obj0 = 0 ;
9781 char *kwnames[] = {
9782 (char *) "self", NULL
9783 };
9784
9785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamily",kwnames,&obj0)) goto fail;
9786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9787 if (SWIG_arg_fail(1)) SWIG_fail;
9788 {
9789 PyThreadState* __tstate = wxPyBeginAllowThreads();
9790 result = (int)((wxFont const *)arg1)->GetFamily();
9791
9792 wxPyEndAllowThreads(__tstate);
9793 if (PyErr_Occurred()) SWIG_fail;
9794 }
9795 {
9796 resultobj = SWIG_From_int((int)(result));
9797 }
9798 return resultobj;
9799 fail:
9800 return NULL;
9801 }
9802
9803
9804 static PyObject *_wrap_Font_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
9805 PyObject *resultobj;
9806 wxFont *arg1 = (wxFont *) 0 ;
9807 int result;
9808 PyObject * obj0 = 0 ;
9809 char *kwnames[] = {
9810 (char *) "self", NULL
9811 };
9812
9813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyle",kwnames,&obj0)) goto fail;
9814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9815 if (SWIG_arg_fail(1)) SWIG_fail;
9816 {
9817 PyThreadState* __tstate = wxPyBeginAllowThreads();
9818 result = (int)((wxFont const *)arg1)->GetStyle();
9819
9820 wxPyEndAllowThreads(__tstate);
9821 if (PyErr_Occurred()) SWIG_fail;
9822 }
9823 {
9824 resultobj = SWIG_From_int((int)(result));
9825 }
9826 return resultobj;
9827 fail:
9828 return NULL;
9829 }
9830
9831
9832 static PyObject *_wrap_Font_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
9833 PyObject *resultobj;
9834 wxFont *arg1 = (wxFont *) 0 ;
9835 int result;
9836 PyObject * obj0 = 0 ;
9837 char *kwnames[] = {
9838 (char *) "self", NULL
9839 };
9840
9841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeight",kwnames,&obj0)) goto fail;
9842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9843 if (SWIG_arg_fail(1)) SWIG_fail;
9844 {
9845 PyThreadState* __tstate = wxPyBeginAllowThreads();
9846 result = (int)((wxFont const *)arg1)->GetWeight();
9847
9848 wxPyEndAllowThreads(__tstate);
9849 if (PyErr_Occurred()) SWIG_fail;
9850 }
9851 {
9852 resultobj = SWIG_From_int((int)(result));
9853 }
9854 return resultobj;
9855 fail:
9856 return NULL;
9857 }
9858
9859
9860 static PyObject *_wrap_Font_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
9861 PyObject *resultobj;
9862 wxFont *arg1 = (wxFont *) 0 ;
9863 bool result;
9864 PyObject * obj0 = 0 ;
9865 char *kwnames[] = {
9866 (char *) "self", NULL
9867 };
9868
9869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetUnderlined",kwnames,&obj0)) goto fail;
9870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9871 if (SWIG_arg_fail(1)) SWIG_fail;
9872 {
9873 PyThreadState* __tstate = wxPyBeginAllowThreads();
9874 result = (bool)((wxFont const *)arg1)->GetUnderlined();
9875
9876 wxPyEndAllowThreads(__tstate);
9877 if (PyErr_Occurred()) SWIG_fail;
9878 }
9879 {
9880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9881 }
9882 return resultobj;
9883 fail:
9884 return NULL;
9885 }
9886
9887
9888 static PyObject *_wrap_Font_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
9889 PyObject *resultobj;
9890 wxFont *arg1 = (wxFont *) 0 ;
9891 wxString result;
9892 PyObject * obj0 = 0 ;
9893 char *kwnames[] = {
9894 (char *) "self", NULL
9895 };
9896
9897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFaceName",kwnames,&obj0)) goto fail;
9898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9899 if (SWIG_arg_fail(1)) SWIG_fail;
9900 {
9901 PyThreadState* __tstate = wxPyBeginAllowThreads();
9902 result = ((wxFont const *)arg1)->GetFaceName();
9903
9904 wxPyEndAllowThreads(__tstate);
9905 if (PyErr_Occurred()) SWIG_fail;
9906 }
9907 {
9908 #if wxUSE_UNICODE
9909 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9910 #else
9911 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9912 #endif
9913 }
9914 return resultobj;
9915 fail:
9916 return NULL;
9917 }
9918
9919
9920 static PyObject *_wrap_Font_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9921 PyObject *resultobj;
9922 wxFont *arg1 = (wxFont *) 0 ;
9923 wxFontEncoding result;
9924 PyObject * obj0 = 0 ;
9925 char *kwnames[] = {
9926 (char *) "self", NULL
9927 };
9928
9929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetEncoding",kwnames,&obj0)) goto fail;
9930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9931 if (SWIG_arg_fail(1)) SWIG_fail;
9932 {
9933 PyThreadState* __tstate = wxPyBeginAllowThreads();
9934 result = (wxFontEncoding)((wxFont const *)arg1)->GetEncoding();
9935
9936 wxPyEndAllowThreads(__tstate);
9937 if (PyErr_Occurred()) SWIG_fail;
9938 }
9939 resultobj = SWIG_From_int((result));
9940 return resultobj;
9941 fail:
9942 return NULL;
9943 }
9944
9945
9946 static PyObject *_wrap_Font_GetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9947 PyObject *resultobj;
9948 wxFont *arg1 = (wxFont *) 0 ;
9949 wxNativeFontInfo *result;
9950 PyObject * obj0 = 0 ;
9951 char *kwnames[] = {
9952 (char *) "self", NULL
9953 };
9954
9955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfo",kwnames,&obj0)) goto fail;
9956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9957 if (SWIG_arg_fail(1)) SWIG_fail;
9958 {
9959 PyThreadState* __tstate = wxPyBeginAllowThreads();
9960 result = (wxNativeFontInfo *)((wxFont const *)arg1)->GetNativeFontInfo();
9961
9962 wxPyEndAllowThreads(__tstate);
9963 if (PyErr_Occurred()) SWIG_fail;
9964 }
9965 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 0);
9966 return resultobj;
9967 fail:
9968 return NULL;
9969 }
9970
9971
9972 static PyObject *_wrap_Font_IsFixedWidth(PyObject *, PyObject *args, PyObject *kwargs) {
9973 PyObject *resultobj;
9974 wxFont *arg1 = (wxFont *) 0 ;
9975 bool result;
9976 PyObject * obj0 = 0 ;
9977 char *kwnames[] = {
9978 (char *) "self", NULL
9979 };
9980
9981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsFixedWidth",kwnames,&obj0)) goto fail;
9982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9983 if (SWIG_arg_fail(1)) SWIG_fail;
9984 {
9985 PyThreadState* __tstate = wxPyBeginAllowThreads();
9986 result = (bool)((wxFont const *)arg1)->IsFixedWidth();
9987
9988 wxPyEndAllowThreads(__tstate);
9989 if (PyErr_Occurred()) SWIG_fail;
9990 }
9991 {
9992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9993 }
9994 return resultobj;
9995 fail:
9996 return NULL;
9997 }
9998
9999
10000 static PyObject *_wrap_Font_GetNativeFontInfoDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10001 PyObject *resultobj;
10002 wxFont *arg1 = (wxFont *) 0 ;
10003 wxString result;
10004 PyObject * obj0 = 0 ;
10005 char *kwnames[] = {
10006 (char *) "self", NULL
10007 };
10008
10009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoDesc",kwnames,&obj0)) goto fail;
10010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10011 if (SWIG_arg_fail(1)) SWIG_fail;
10012 {
10013 PyThreadState* __tstate = wxPyBeginAllowThreads();
10014 result = ((wxFont const *)arg1)->GetNativeFontInfoDesc();
10015
10016 wxPyEndAllowThreads(__tstate);
10017 if (PyErr_Occurred()) SWIG_fail;
10018 }
10019 {
10020 #if wxUSE_UNICODE
10021 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10022 #else
10023 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10024 #endif
10025 }
10026 return resultobj;
10027 fail:
10028 return NULL;
10029 }
10030
10031
10032 static PyObject *_wrap_Font_GetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10033 PyObject *resultobj;
10034 wxFont *arg1 = (wxFont *) 0 ;
10035 wxString result;
10036 PyObject * obj0 = 0 ;
10037 char *kwnames[] = {
10038 (char *) "self", NULL
10039 };
10040
10041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoUserDesc",kwnames,&obj0)) goto fail;
10042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10043 if (SWIG_arg_fail(1)) SWIG_fail;
10044 {
10045 PyThreadState* __tstate = wxPyBeginAllowThreads();
10046 result = ((wxFont const *)arg1)->GetNativeFontInfoUserDesc();
10047
10048 wxPyEndAllowThreads(__tstate);
10049 if (PyErr_Occurred()) SWIG_fail;
10050 }
10051 {
10052 #if wxUSE_UNICODE
10053 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10054 #else
10055 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10056 #endif
10057 }
10058 return resultobj;
10059 fail:
10060 return NULL;
10061 }
10062
10063
10064 static PyObject *_wrap_Font_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
10065 PyObject *resultobj;
10066 wxFont *arg1 = (wxFont *) 0 ;
10067 int arg2 ;
10068 PyObject * obj0 = 0 ;
10069 PyObject * obj1 = 0 ;
10070 char *kwnames[] = {
10071 (char *) "self",(char *) "pointSize", NULL
10072 };
10073
10074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
10075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10076 if (SWIG_arg_fail(1)) SWIG_fail;
10077 {
10078 arg2 = (int)(SWIG_As_int(obj1));
10079 if (SWIG_arg_fail(2)) SWIG_fail;
10080 }
10081 {
10082 PyThreadState* __tstate = wxPyBeginAllowThreads();
10083 (arg1)->SetPointSize(arg2);
10084
10085 wxPyEndAllowThreads(__tstate);
10086 if (PyErr_Occurred()) SWIG_fail;
10087 }
10088 Py_INCREF(Py_None); resultobj = Py_None;
10089 return resultobj;
10090 fail:
10091 return NULL;
10092 }
10093
10094
10095 static PyObject *_wrap_Font_SetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10096 PyObject *resultobj;
10097 wxFont *arg1 = (wxFont *) 0 ;
10098 wxSize *arg2 = 0 ;
10099 wxSize temp2 ;
10100 PyObject * obj0 = 0 ;
10101 PyObject * obj1 = 0 ;
10102 char *kwnames[] = {
10103 (char *) "self",(char *) "pixelSize", NULL
10104 };
10105
10106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPixelSize",kwnames,&obj0,&obj1)) goto fail;
10107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10108 if (SWIG_arg_fail(1)) SWIG_fail;
10109 {
10110 arg2 = &temp2;
10111 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
10112 }
10113 {
10114 PyThreadState* __tstate = wxPyBeginAllowThreads();
10115 (arg1)->SetPixelSize((wxSize const &)*arg2);
10116
10117 wxPyEndAllowThreads(__tstate);
10118 if (PyErr_Occurred()) SWIG_fail;
10119 }
10120 Py_INCREF(Py_None); resultobj = Py_None;
10121 return resultobj;
10122 fail:
10123 return NULL;
10124 }
10125
10126
10127 static PyObject *_wrap_Font_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
10128 PyObject *resultobj;
10129 wxFont *arg1 = (wxFont *) 0 ;
10130 int arg2 ;
10131 PyObject * obj0 = 0 ;
10132 PyObject * obj1 = 0 ;
10133 char *kwnames[] = {
10134 (char *) "self",(char *) "family", NULL
10135 };
10136
10137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFamily",kwnames,&obj0,&obj1)) goto fail;
10138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10139 if (SWIG_arg_fail(1)) SWIG_fail;
10140 {
10141 arg2 = (int)(SWIG_As_int(obj1));
10142 if (SWIG_arg_fail(2)) SWIG_fail;
10143 }
10144 {
10145 PyThreadState* __tstate = wxPyBeginAllowThreads();
10146 (arg1)->SetFamily(arg2);
10147
10148 wxPyEndAllowThreads(__tstate);
10149 if (PyErr_Occurred()) SWIG_fail;
10150 }
10151 Py_INCREF(Py_None); resultobj = Py_None;
10152 return resultobj;
10153 fail:
10154 return NULL;
10155 }
10156
10157
10158 static PyObject *_wrap_Font_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10159 PyObject *resultobj;
10160 wxFont *arg1 = (wxFont *) 0 ;
10161 int arg2 ;
10162 PyObject * obj0 = 0 ;
10163 PyObject * obj1 = 0 ;
10164 char *kwnames[] = {
10165 (char *) "self",(char *) "style", NULL
10166 };
10167
10168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetStyle",kwnames,&obj0,&obj1)) goto fail;
10169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10170 if (SWIG_arg_fail(1)) SWIG_fail;
10171 {
10172 arg2 = (int)(SWIG_As_int(obj1));
10173 if (SWIG_arg_fail(2)) SWIG_fail;
10174 }
10175 {
10176 PyThreadState* __tstate = wxPyBeginAllowThreads();
10177 (arg1)->SetStyle(arg2);
10178
10179 wxPyEndAllowThreads(__tstate);
10180 if (PyErr_Occurred()) SWIG_fail;
10181 }
10182 Py_INCREF(Py_None); resultobj = Py_None;
10183 return resultobj;
10184 fail:
10185 return NULL;
10186 }
10187
10188
10189 static PyObject *_wrap_Font_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
10190 PyObject *resultobj;
10191 wxFont *arg1 = (wxFont *) 0 ;
10192 int arg2 ;
10193 PyObject * obj0 = 0 ;
10194 PyObject * obj1 = 0 ;
10195 char *kwnames[] = {
10196 (char *) "self",(char *) "weight", NULL
10197 };
10198
10199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetWeight",kwnames,&obj0,&obj1)) goto fail;
10200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10201 if (SWIG_arg_fail(1)) SWIG_fail;
10202 {
10203 arg2 = (int)(SWIG_As_int(obj1));
10204 if (SWIG_arg_fail(2)) SWIG_fail;
10205 }
10206 {
10207 PyThreadState* __tstate = wxPyBeginAllowThreads();
10208 (arg1)->SetWeight(arg2);
10209
10210 wxPyEndAllowThreads(__tstate);
10211 if (PyErr_Occurred()) SWIG_fail;
10212 }
10213 Py_INCREF(Py_None); resultobj = Py_None;
10214 return resultobj;
10215 fail:
10216 return NULL;
10217 }
10218
10219
10220 static PyObject *_wrap_Font_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
10221 PyObject *resultobj;
10222 wxFont *arg1 = (wxFont *) 0 ;
10223 wxString *arg2 = 0 ;
10224 bool temp2 = false ;
10225 PyObject * obj0 = 0 ;
10226 PyObject * obj1 = 0 ;
10227 char *kwnames[] = {
10228 (char *) "self",(char *) "faceName", NULL
10229 };
10230
10231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
10232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10233 if (SWIG_arg_fail(1)) SWIG_fail;
10234 {
10235 arg2 = wxString_in_helper(obj1);
10236 if (arg2 == NULL) SWIG_fail;
10237 temp2 = true;
10238 }
10239 {
10240 PyThreadState* __tstate = wxPyBeginAllowThreads();
10241 (arg1)->SetFaceName((wxString const &)*arg2);
10242
10243 wxPyEndAllowThreads(__tstate);
10244 if (PyErr_Occurred()) SWIG_fail;
10245 }
10246 Py_INCREF(Py_None); resultobj = Py_None;
10247 {
10248 if (temp2)
10249 delete arg2;
10250 }
10251 return resultobj;
10252 fail:
10253 {
10254 if (temp2)
10255 delete arg2;
10256 }
10257 return NULL;
10258 }
10259
10260
10261 static PyObject *_wrap_Font_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
10262 PyObject *resultobj;
10263 wxFont *arg1 = (wxFont *) 0 ;
10264 bool arg2 ;
10265 PyObject * obj0 = 0 ;
10266 PyObject * obj1 = 0 ;
10267 char *kwnames[] = {
10268 (char *) "self",(char *) "underlined", NULL
10269 };
10270
10271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
10272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10273 if (SWIG_arg_fail(1)) SWIG_fail;
10274 {
10275 arg2 = (bool)(SWIG_As_bool(obj1));
10276 if (SWIG_arg_fail(2)) SWIG_fail;
10277 }
10278 {
10279 PyThreadState* __tstate = wxPyBeginAllowThreads();
10280 (arg1)->SetUnderlined(arg2);
10281
10282 wxPyEndAllowThreads(__tstate);
10283 if (PyErr_Occurred()) SWIG_fail;
10284 }
10285 Py_INCREF(Py_None); resultobj = Py_None;
10286 return resultobj;
10287 fail:
10288 return NULL;
10289 }
10290
10291
10292 static PyObject *_wrap_Font_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10293 PyObject *resultobj;
10294 wxFont *arg1 = (wxFont *) 0 ;
10295 wxFontEncoding arg2 ;
10296 PyObject * obj0 = 0 ;
10297 PyObject * obj1 = 0 ;
10298 char *kwnames[] = {
10299 (char *) "self",(char *) "encoding", NULL
10300 };
10301
10302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
10303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10304 if (SWIG_arg_fail(1)) SWIG_fail;
10305 {
10306 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10307 if (SWIG_arg_fail(2)) SWIG_fail;
10308 }
10309 {
10310 PyThreadState* __tstate = wxPyBeginAllowThreads();
10311 (arg1)->SetEncoding((wxFontEncoding )arg2);
10312
10313 wxPyEndAllowThreads(__tstate);
10314 if (PyErr_Occurred()) SWIG_fail;
10315 }
10316 Py_INCREF(Py_None); resultobj = Py_None;
10317 return resultobj;
10318 fail:
10319 return NULL;
10320 }
10321
10322
10323 static PyObject *_wrap_Font_SetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10324 PyObject *resultobj;
10325 wxFont *arg1 = (wxFont *) 0 ;
10326 wxNativeFontInfo *arg2 = 0 ;
10327 PyObject * obj0 = 0 ;
10328 PyObject * obj1 = 0 ;
10329 char *kwnames[] = {
10330 (char *) "self",(char *) "info", NULL
10331 };
10332
10333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfo",kwnames,&obj0,&obj1)) goto fail;
10334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10335 if (SWIG_arg_fail(1)) SWIG_fail;
10336 {
10337 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
10338 if (SWIG_arg_fail(2)) SWIG_fail;
10339 if (arg2 == NULL) {
10340 SWIG_null_ref("wxNativeFontInfo");
10341 }
10342 if (SWIG_arg_fail(2)) SWIG_fail;
10343 }
10344 {
10345 PyThreadState* __tstate = wxPyBeginAllowThreads();
10346 (arg1)->SetNativeFontInfo((wxNativeFontInfo const &)*arg2);
10347
10348 wxPyEndAllowThreads(__tstate);
10349 if (PyErr_Occurred()) SWIG_fail;
10350 }
10351 Py_INCREF(Py_None); resultobj = Py_None;
10352 return resultobj;
10353 fail:
10354 return NULL;
10355 }
10356
10357
10358 static PyObject *_wrap_Font_SetNativeFontInfoFromString(PyObject *, PyObject *args, PyObject *kwargs) {
10359 PyObject *resultobj;
10360 wxFont *arg1 = (wxFont *) 0 ;
10361 wxString *arg2 = 0 ;
10362 bool temp2 = false ;
10363 PyObject * obj0 = 0 ;
10364 PyObject * obj1 = 0 ;
10365 char *kwnames[] = {
10366 (char *) "self",(char *) "info", NULL
10367 };
10368
10369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoFromString",kwnames,&obj0,&obj1)) goto fail;
10370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10371 if (SWIG_arg_fail(1)) SWIG_fail;
10372 {
10373 arg2 = wxString_in_helper(obj1);
10374 if (arg2 == NULL) SWIG_fail;
10375 temp2 = true;
10376 }
10377 {
10378 PyThreadState* __tstate = wxPyBeginAllowThreads();
10379 (arg1)->SetNativeFontInfo((wxString const &)*arg2);
10380
10381 wxPyEndAllowThreads(__tstate);
10382 if (PyErr_Occurred()) SWIG_fail;
10383 }
10384 Py_INCREF(Py_None); resultobj = Py_None;
10385 {
10386 if (temp2)
10387 delete arg2;
10388 }
10389 return resultobj;
10390 fail:
10391 {
10392 if (temp2)
10393 delete arg2;
10394 }
10395 return NULL;
10396 }
10397
10398
10399 static PyObject *_wrap_Font_SetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10400 PyObject *resultobj;
10401 wxFont *arg1 = (wxFont *) 0 ;
10402 wxString *arg2 = 0 ;
10403 bool temp2 = false ;
10404 PyObject * obj0 = 0 ;
10405 PyObject * obj1 = 0 ;
10406 char *kwnames[] = {
10407 (char *) "self",(char *) "info", NULL
10408 };
10409
10410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoUserDesc",kwnames,&obj0,&obj1)) goto fail;
10411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10412 if (SWIG_arg_fail(1)) SWIG_fail;
10413 {
10414 arg2 = wxString_in_helper(obj1);
10415 if (arg2 == NULL) SWIG_fail;
10416 temp2 = true;
10417 }
10418 {
10419 PyThreadState* __tstate = wxPyBeginAllowThreads();
10420 (arg1)->SetNativeFontInfoUserDesc((wxString const &)*arg2);
10421
10422 wxPyEndAllowThreads(__tstate);
10423 if (PyErr_Occurred()) SWIG_fail;
10424 }
10425 Py_INCREF(Py_None); resultobj = Py_None;
10426 {
10427 if (temp2)
10428 delete arg2;
10429 }
10430 return resultobj;
10431 fail:
10432 {
10433 if (temp2)
10434 delete arg2;
10435 }
10436 return NULL;
10437 }
10438
10439
10440 static PyObject *_wrap_Font_GetFamilyString(PyObject *, PyObject *args, PyObject *kwargs) {
10441 PyObject *resultobj;
10442 wxFont *arg1 = (wxFont *) 0 ;
10443 wxString result;
10444 PyObject * obj0 = 0 ;
10445 char *kwnames[] = {
10446 (char *) "self", NULL
10447 };
10448
10449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamilyString",kwnames,&obj0)) goto fail;
10450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10451 if (SWIG_arg_fail(1)) SWIG_fail;
10452 {
10453 PyThreadState* __tstate = wxPyBeginAllowThreads();
10454 result = ((wxFont const *)arg1)->GetFamilyString();
10455
10456 wxPyEndAllowThreads(__tstate);
10457 if (PyErr_Occurred()) SWIG_fail;
10458 }
10459 {
10460 #if wxUSE_UNICODE
10461 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10462 #else
10463 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10464 #endif
10465 }
10466 return resultobj;
10467 fail:
10468 return NULL;
10469 }
10470
10471
10472 static PyObject *_wrap_Font_GetStyleString(PyObject *, PyObject *args, PyObject *kwargs) {
10473 PyObject *resultobj;
10474 wxFont *arg1 = (wxFont *) 0 ;
10475 wxString result;
10476 PyObject * obj0 = 0 ;
10477 char *kwnames[] = {
10478 (char *) "self", NULL
10479 };
10480
10481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyleString",kwnames,&obj0)) goto fail;
10482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10483 if (SWIG_arg_fail(1)) SWIG_fail;
10484 {
10485 PyThreadState* __tstate = wxPyBeginAllowThreads();
10486 result = ((wxFont const *)arg1)->GetStyleString();
10487
10488 wxPyEndAllowThreads(__tstate);
10489 if (PyErr_Occurred()) SWIG_fail;
10490 }
10491 {
10492 #if wxUSE_UNICODE
10493 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10494 #else
10495 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10496 #endif
10497 }
10498 return resultobj;
10499 fail:
10500 return NULL;
10501 }
10502
10503
10504 static PyObject *_wrap_Font_GetWeightString(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_GetWeightString",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)->GetWeightString();
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_SetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
10537 PyObject *resultobj;
10538 wxFont *arg1 = (wxFont *) 0 ;
10539 bool arg2 = (bool) true ;
10540 PyObject * obj0 = 0 ;
10541 PyObject * obj1 = 0 ;
10542 char *kwnames[] = {
10543 (char *) "self",(char *) "no", NULL
10544 };
10545
10546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Font_SetNoAntiAliasing",kwnames,&obj0,&obj1)) goto fail;
10547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10548 if (SWIG_arg_fail(1)) SWIG_fail;
10549 if (obj1) {
10550 {
10551 arg2 = (bool)(SWIG_As_bool(obj1));
10552 if (SWIG_arg_fail(2)) SWIG_fail;
10553 }
10554 }
10555 {
10556 PyThreadState* __tstate = wxPyBeginAllowThreads();
10557 (arg1)->SetNoAntiAliasing(arg2);
10558
10559 wxPyEndAllowThreads(__tstate);
10560 if (PyErr_Occurred()) SWIG_fail;
10561 }
10562 Py_INCREF(Py_None); resultobj = Py_None;
10563 return resultobj;
10564 fail:
10565 return NULL;
10566 }
10567
10568
10569 static PyObject *_wrap_Font_GetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
10570 PyObject *resultobj;
10571 wxFont *arg1 = (wxFont *) 0 ;
10572 bool result;
10573 PyObject * obj0 = 0 ;
10574 char *kwnames[] = {
10575 (char *) "self", NULL
10576 };
10577
10578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNoAntiAliasing",kwnames,&obj0)) goto fail;
10579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10580 if (SWIG_arg_fail(1)) SWIG_fail;
10581 {
10582 PyThreadState* __tstate = wxPyBeginAllowThreads();
10583 result = (bool)((wxFont const *)arg1)->GetNoAntiAliasing();
10584
10585 wxPyEndAllowThreads(__tstate);
10586 if (PyErr_Occurred()) SWIG_fail;
10587 }
10588 {
10589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10590 }
10591 return resultobj;
10592 fail:
10593 return NULL;
10594 }
10595
10596
10597 static PyObject *_wrap_Font_GetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10598 PyObject *resultobj;
10599 wxFontEncoding result;
10600 char *kwnames[] = {
10601 NULL
10602 };
10603
10604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Font_GetDefaultEncoding",kwnames)) goto fail;
10605 {
10606 if (!wxPyCheckForApp()) SWIG_fail;
10607 PyThreadState* __tstate = wxPyBeginAllowThreads();
10608 result = (wxFontEncoding)wxFont::GetDefaultEncoding();
10609
10610 wxPyEndAllowThreads(__tstate);
10611 if (PyErr_Occurred()) SWIG_fail;
10612 }
10613 resultobj = SWIG_From_int((result));
10614 return resultobj;
10615 fail:
10616 return NULL;
10617 }
10618
10619
10620 static PyObject *_wrap_Font_SetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10621 PyObject *resultobj;
10622 wxFontEncoding arg1 ;
10623 PyObject * obj0 = 0 ;
10624 char *kwnames[] = {
10625 (char *) "encoding", NULL
10626 };
10627
10628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_SetDefaultEncoding",kwnames,&obj0)) goto fail;
10629 {
10630 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
10631 if (SWIG_arg_fail(1)) SWIG_fail;
10632 }
10633 {
10634 if (!wxPyCheckForApp()) SWIG_fail;
10635 PyThreadState* __tstate = wxPyBeginAllowThreads();
10636 wxFont::SetDefaultEncoding((wxFontEncoding )arg1);
10637
10638 wxPyEndAllowThreads(__tstate);
10639 if (PyErr_Occurred()) SWIG_fail;
10640 }
10641 Py_INCREF(Py_None); resultobj = Py_None;
10642 return resultobj;
10643 fail:
10644 return NULL;
10645 }
10646
10647
10648 static PyObject * Font_swigregister(PyObject *, PyObject *args) {
10649 PyObject *obj;
10650 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10651 SWIG_TypeClientData(SWIGTYPE_p_wxFont, obj);
10652 Py_INCREF(obj);
10653 return Py_BuildValue((char *)"");
10654 }
10655 static PyObject *_wrap_new_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
10656 PyObject *resultobj;
10657 wxPyFontEnumerator *result;
10658 char *kwnames[] = {
10659 NULL
10660 };
10661
10662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontEnumerator",kwnames)) goto fail;
10663 {
10664 if (!wxPyCheckForApp()) SWIG_fail;
10665 PyThreadState* __tstate = wxPyBeginAllowThreads();
10666 result = (wxPyFontEnumerator *)new wxPyFontEnumerator();
10667
10668 wxPyEndAllowThreads(__tstate);
10669 if (PyErr_Occurred()) SWIG_fail;
10670 }
10671 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFontEnumerator, 1);
10672 return resultobj;
10673 fail:
10674 return NULL;
10675 }
10676
10677
10678 static PyObject *_wrap_delete_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
10679 PyObject *resultobj;
10680 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10681 PyObject * obj0 = 0 ;
10682 char *kwnames[] = {
10683 (char *) "self", NULL
10684 };
10685
10686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontEnumerator",kwnames,&obj0)) goto fail;
10687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10688 if (SWIG_arg_fail(1)) SWIG_fail;
10689 {
10690 PyThreadState* __tstate = wxPyBeginAllowThreads();
10691 delete arg1;
10692
10693 wxPyEndAllowThreads(__tstate);
10694 if (PyErr_Occurred()) SWIG_fail;
10695 }
10696 Py_INCREF(Py_None); resultobj = Py_None;
10697 return resultobj;
10698 fail:
10699 return NULL;
10700 }
10701
10702
10703 static PyObject *_wrap_FontEnumerator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10704 PyObject *resultobj;
10705 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10706 PyObject *arg2 = (PyObject *) 0 ;
10707 PyObject *arg3 = (PyObject *) 0 ;
10708 bool arg4 ;
10709 PyObject * obj0 = 0 ;
10710 PyObject * obj1 = 0 ;
10711 PyObject * obj2 = 0 ;
10712 PyObject * obj3 = 0 ;
10713 char *kwnames[] = {
10714 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10715 };
10716
10717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FontEnumerator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10719 if (SWIG_arg_fail(1)) SWIG_fail;
10720 arg2 = obj1;
10721 arg3 = obj2;
10722 {
10723 arg4 = (bool)(SWIG_As_bool(obj3));
10724 if (SWIG_arg_fail(4)) SWIG_fail;
10725 }
10726 {
10727 PyThreadState* __tstate = wxPyBeginAllowThreads();
10728 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10729
10730 wxPyEndAllowThreads(__tstate);
10731 if (PyErr_Occurred()) SWIG_fail;
10732 }
10733 Py_INCREF(Py_None); resultobj = Py_None;
10734 return resultobj;
10735 fail:
10736 return NULL;
10737 }
10738
10739
10740 static PyObject *_wrap_FontEnumerator_EnumerateFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
10741 PyObject *resultobj;
10742 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10743 wxFontEncoding arg2 = (wxFontEncoding) wxFONTENCODING_SYSTEM ;
10744 bool arg3 = (bool) false ;
10745 bool result;
10746 PyObject * obj0 = 0 ;
10747 PyObject * obj1 = 0 ;
10748 PyObject * obj2 = 0 ;
10749 char *kwnames[] = {
10750 (char *) "self",(char *) "encoding",(char *) "fixedWidthOnly", NULL
10751 };
10752
10753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FontEnumerator_EnumerateFacenames",kwnames,&obj0,&obj1,&obj2)) goto fail;
10754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10755 if (SWIG_arg_fail(1)) SWIG_fail;
10756 if (obj1) {
10757 {
10758 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10759 if (SWIG_arg_fail(2)) SWIG_fail;
10760 }
10761 }
10762 if (obj2) {
10763 {
10764 arg3 = (bool)(SWIG_As_bool(obj2));
10765 if (SWIG_arg_fail(3)) SWIG_fail;
10766 }
10767 }
10768 {
10769 PyThreadState* __tstate = wxPyBeginAllowThreads();
10770 result = (bool)(arg1)->EnumerateFacenames((wxFontEncoding )arg2,arg3);
10771
10772 wxPyEndAllowThreads(__tstate);
10773 if (PyErr_Occurred()) SWIG_fail;
10774 }
10775 {
10776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10777 }
10778 return resultobj;
10779 fail:
10780 return NULL;
10781 }
10782
10783
10784 static PyObject *_wrap_FontEnumerator_EnumerateEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
10785 PyObject *resultobj;
10786 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10787 wxString const &arg2_defvalue = wxPyEmptyString ;
10788 wxString *arg2 = (wxString *) &arg2_defvalue ;
10789 bool result;
10790 bool temp2 = false ;
10791 PyObject * obj0 = 0 ;
10792 PyObject * obj1 = 0 ;
10793 char *kwnames[] = {
10794 (char *) "self",(char *) "facename", NULL
10795 };
10796
10797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FontEnumerator_EnumerateEncodings",kwnames,&obj0,&obj1)) goto fail;
10798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10799 if (SWIG_arg_fail(1)) SWIG_fail;
10800 if (obj1) {
10801 {
10802 arg2 = wxString_in_helper(obj1);
10803 if (arg2 == NULL) SWIG_fail;
10804 temp2 = true;
10805 }
10806 }
10807 {
10808 PyThreadState* __tstate = wxPyBeginAllowThreads();
10809 result = (bool)(arg1)->EnumerateEncodings((wxString const &)*arg2);
10810
10811 wxPyEndAllowThreads(__tstate);
10812 if (PyErr_Occurred()) SWIG_fail;
10813 }
10814 {
10815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10816 }
10817 {
10818 if (temp2)
10819 delete arg2;
10820 }
10821 return resultobj;
10822 fail:
10823 {
10824 if (temp2)
10825 delete arg2;
10826 }
10827 return NULL;
10828 }
10829
10830
10831 static PyObject *_wrap_FontEnumerator_GetEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
10832 PyObject *resultobj;
10833 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10834 PyObject *result;
10835 PyObject * obj0 = 0 ;
10836 char *kwnames[] = {
10837 (char *) "self", NULL
10838 };
10839
10840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetEncodings",kwnames,&obj0)) goto fail;
10841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10842 if (SWIG_arg_fail(1)) SWIG_fail;
10843 {
10844 PyThreadState* __tstate = wxPyBeginAllowThreads();
10845 result = (PyObject *)wxPyFontEnumerator_GetEncodings(arg1);
10846
10847 wxPyEndAllowThreads(__tstate);
10848 if (PyErr_Occurred()) SWIG_fail;
10849 }
10850 resultobj = result;
10851 return resultobj;
10852 fail:
10853 return NULL;
10854 }
10855
10856
10857 static PyObject *_wrap_FontEnumerator_GetFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
10858 PyObject *resultobj;
10859 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10860 PyObject *result;
10861 PyObject * obj0 = 0 ;
10862 char *kwnames[] = {
10863 (char *) "self", NULL
10864 };
10865
10866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetFacenames",kwnames,&obj0)) goto fail;
10867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10868 if (SWIG_arg_fail(1)) SWIG_fail;
10869 {
10870 PyThreadState* __tstate = wxPyBeginAllowThreads();
10871 result = (PyObject *)wxPyFontEnumerator_GetFacenames(arg1);
10872
10873 wxPyEndAllowThreads(__tstate);
10874 if (PyErr_Occurred()) SWIG_fail;
10875 }
10876 resultobj = result;
10877 return resultobj;
10878 fail:
10879 return NULL;
10880 }
10881
10882
10883 static PyObject * FontEnumerator_swigregister(PyObject *, PyObject *args) {
10884 PyObject *obj;
10885 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10886 SWIG_TypeClientData(SWIGTYPE_p_wxPyFontEnumerator, obj);
10887 Py_INCREF(obj);
10888 return Py_BuildValue((char *)"");
10889 }
10890 static PyObject *_wrap_LanguageInfo_Language_set(PyObject *, PyObject *args, PyObject *kwargs) {
10891 PyObject *resultobj;
10892 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10893 int arg2 ;
10894 PyObject * obj0 = 0 ;
10895 PyObject * obj1 = 0 ;
10896 char *kwnames[] = {
10897 (char *) "self",(char *) "Language", NULL
10898 };
10899
10900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Language_set",kwnames,&obj0,&obj1)) goto fail;
10901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10902 if (SWIG_arg_fail(1)) SWIG_fail;
10903 {
10904 arg2 = (int)(SWIG_As_int(obj1));
10905 if (SWIG_arg_fail(2)) SWIG_fail;
10906 }
10907 if (arg1) (arg1)->Language = arg2;
10908
10909 Py_INCREF(Py_None); resultobj = Py_None;
10910 return resultobj;
10911 fail:
10912 return NULL;
10913 }
10914
10915
10916 static PyObject *_wrap_LanguageInfo_Language_get(PyObject *, PyObject *args, PyObject *kwargs) {
10917 PyObject *resultobj;
10918 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10919 int result;
10920 PyObject * obj0 = 0 ;
10921 char *kwnames[] = {
10922 (char *) "self", NULL
10923 };
10924
10925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Language_get",kwnames,&obj0)) goto fail;
10926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10927 if (SWIG_arg_fail(1)) SWIG_fail;
10928 result = (int) ((arg1)->Language);
10929
10930 {
10931 resultobj = SWIG_From_int((int)(result));
10932 }
10933 return resultobj;
10934 fail:
10935 return NULL;
10936 }
10937
10938
10939 static PyObject *_wrap_LanguageInfo_CanonicalName_set(PyObject *, PyObject *args, PyObject *kwargs) {
10940 PyObject *resultobj;
10941 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10942 wxString *arg2 = (wxString *) 0 ;
10943 bool temp2 = false ;
10944 PyObject * obj0 = 0 ;
10945 PyObject * obj1 = 0 ;
10946 char *kwnames[] = {
10947 (char *) "self",(char *) "CanonicalName", NULL
10948 };
10949
10950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_CanonicalName_set",kwnames,&obj0,&obj1)) goto fail;
10951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10952 if (SWIG_arg_fail(1)) SWIG_fail;
10953 {
10954 arg2 = wxString_in_helper(obj1);
10955 if (arg2 == NULL) SWIG_fail;
10956 temp2 = true;
10957 }
10958 if (arg1) (arg1)->CanonicalName = *arg2;
10959
10960 Py_INCREF(Py_None); resultobj = Py_None;
10961 {
10962 if (temp2)
10963 delete arg2;
10964 }
10965 return resultobj;
10966 fail:
10967 {
10968 if (temp2)
10969 delete arg2;
10970 }
10971 return NULL;
10972 }
10973
10974
10975 static PyObject *_wrap_LanguageInfo_CanonicalName_get(PyObject *, PyObject *args, PyObject *kwargs) {
10976 PyObject *resultobj;
10977 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10978 wxString *result;
10979 PyObject * obj0 = 0 ;
10980 char *kwnames[] = {
10981 (char *) "self", NULL
10982 };
10983
10984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_CanonicalName_get",kwnames,&obj0)) goto fail;
10985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10986 if (SWIG_arg_fail(1)) SWIG_fail;
10987 result = (wxString *)& ((arg1)->CanonicalName);
10988
10989 {
10990 #if wxUSE_UNICODE
10991 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10992 #else
10993 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10994 #endif
10995 }
10996 return resultobj;
10997 fail:
10998 return NULL;
10999 }
11000
11001
11002 static PyObject *_wrap_LanguageInfo_Description_set(PyObject *, PyObject *args, PyObject *kwargs) {
11003 PyObject *resultobj;
11004 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11005 wxString *arg2 = (wxString *) 0 ;
11006 bool temp2 = false ;
11007 PyObject * obj0 = 0 ;
11008 PyObject * obj1 = 0 ;
11009 char *kwnames[] = {
11010 (char *) "self",(char *) "Description", NULL
11011 };
11012
11013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Description_set",kwnames,&obj0,&obj1)) goto fail;
11014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11015 if (SWIG_arg_fail(1)) SWIG_fail;
11016 {
11017 arg2 = wxString_in_helper(obj1);
11018 if (arg2 == NULL) SWIG_fail;
11019 temp2 = true;
11020 }
11021 if (arg1) (arg1)->Description = *arg2;
11022
11023 Py_INCREF(Py_None); resultobj = Py_None;
11024 {
11025 if (temp2)
11026 delete arg2;
11027 }
11028 return resultobj;
11029 fail:
11030 {
11031 if (temp2)
11032 delete arg2;
11033 }
11034 return NULL;
11035 }
11036
11037
11038 static PyObject *_wrap_LanguageInfo_Description_get(PyObject *, PyObject *args, PyObject *kwargs) {
11039 PyObject *resultobj;
11040 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11041 wxString *result;
11042 PyObject * obj0 = 0 ;
11043 char *kwnames[] = {
11044 (char *) "self", NULL
11045 };
11046
11047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Description_get",kwnames,&obj0)) goto fail;
11048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11049 if (SWIG_arg_fail(1)) SWIG_fail;
11050 result = (wxString *)& ((arg1)->Description);
11051
11052 {
11053 #if wxUSE_UNICODE
11054 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11055 #else
11056 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11057 #endif
11058 }
11059 return resultobj;
11060 fail:
11061 return NULL;
11062 }
11063
11064
11065 static PyObject * LanguageInfo_swigregister(PyObject *, PyObject *args) {
11066 PyObject *obj;
11067 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11068 SWIG_TypeClientData(SWIGTYPE_p_wxLanguageInfo, obj);
11069 Py_INCREF(obj);
11070 return Py_BuildValue((char *)"");
11071 }
11072 static PyObject *_wrap_new_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11073 PyObject *resultobj;
11074 int arg1 = (int) -1 ;
11075 int arg2 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11076 wxLocale *result;
11077 PyObject * obj0 = 0 ;
11078 PyObject * obj1 = 0 ;
11079 char *kwnames[] = {
11080 (char *) "language",(char *) "flags", NULL
11081 };
11082
11083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Locale",kwnames,&obj0,&obj1)) goto fail;
11084 if (obj0) {
11085 {
11086 arg1 = (int)(SWIG_As_int(obj0));
11087 if (SWIG_arg_fail(1)) SWIG_fail;
11088 }
11089 }
11090 if (obj1) {
11091 {
11092 arg2 = (int)(SWIG_As_int(obj1));
11093 if (SWIG_arg_fail(2)) SWIG_fail;
11094 }
11095 }
11096 {
11097 PyThreadState* __tstate = wxPyBeginAllowThreads();
11098 result = (wxLocale *)new_wxLocale(arg1,arg2);
11099
11100 wxPyEndAllowThreads(__tstate);
11101 if (PyErr_Occurred()) SWIG_fail;
11102 }
11103 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 1);
11104 return resultobj;
11105 fail:
11106 return NULL;
11107 }
11108
11109
11110 static PyObject *_wrap_delete_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11111 PyObject *resultobj;
11112 wxLocale *arg1 = (wxLocale *) 0 ;
11113 PyObject * obj0 = 0 ;
11114 char *kwnames[] = {
11115 (char *) "self", NULL
11116 };
11117
11118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Locale",kwnames,&obj0)) goto fail;
11119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11120 if (SWIG_arg_fail(1)) SWIG_fail;
11121 {
11122 PyThreadState* __tstate = wxPyBeginAllowThreads();
11123 delete arg1;
11124
11125 wxPyEndAllowThreads(__tstate);
11126 if (PyErr_Occurred()) SWIG_fail;
11127 }
11128 Py_INCREF(Py_None); resultobj = Py_None;
11129 return resultobj;
11130 fail:
11131 return NULL;
11132 }
11133
11134
11135 static PyObject *_wrap_Locale_Init1(PyObject *, PyObject *args, PyObject *kwargs) {
11136 PyObject *resultobj;
11137 wxLocale *arg1 = (wxLocale *) 0 ;
11138 wxString *arg2 = 0 ;
11139 wxString const &arg3_defvalue = wxPyEmptyString ;
11140 wxString *arg3 = (wxString *) &arg3_defvalue ;
11141 wxString const &arg4_defvalue = wxPyEmptyString ;
11142 wxString *arg4 = (wxString *) &arg4_defvalue ;
11143 bool arg5 = (bool) true ;
11144 bool arg6 = (bool) false ;
11145 bool result;
11146 bool temp2 = false ;
11147 bool temp3 = false ;
11148 bool temp4 = false ;
11149 PyObject * obj0 = 0 ;
11150 PyObject * obj1 = 0 ;
11151 PyObject * obj2 = 0 ;
11152 PyObject * obj3 = 0 ;
11153 PyObject * obj4 = 0 ;
11154 PyObject * obj5 = 0 ;
11155 char *kwnames[] = {
11156 (char *) "self",(char *) "szName",(char *) "szShort",(char *) "szLocale",(char *) "bLoadDefault",(char *) "bConvertEncoding", NULL
11157 };
11158
11159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Locale_Init1",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11161 if (SWIG_arg_fail(1)) SWIG_fail;
11162 {
11163 arg2 = wxString_in_helper(obj1);
11164 if (arg2 == NULL) SWIG_fail;
11165 temp2 = true;
11166 }
11167 if (obj2) {
11168 {
11169 arg3 = wxString_in_helper(obj2);
11170 if (arg3 == NULL) SWIG_fail;
11171 temp3 = true;
11172 }
11173 }
11174 if (obj3) {
11175 {
11176 arg4 = wxString_in_helper(obj3);
11177 if (arg4 == NULL) SWIG_fail;
11178 temp4 = true;
11179 }
11180 }
11181 if (obj4) {
11182 {
11183 arg5 = (bool)(SWIG_As_bool(obj4));
11184 if (SWIG_arg_fail(5)) SWIG_fail;
11185 }
11186 }
11187 if (obj5) {
11188 {
11189 arg6 = (bool)(SWIG_As_bool(obj5));
11190 if (SWIG_arg_fail(6)) SWIG_fail;
11191 }
11192 }
11193 {
11194 PyThreadState* __tstate = wxPyBeginAllowThreads();
11195 result = (bool)wxLocale_Init1(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
11196
11197 wxPyEndAllowThreads(__tstate);
11198 if (PyErr_Occurred()) SWIG_fail;
11199 }
11200 {
11201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11202 }
11203 {
11204 if (temp2)
11205 delete arg2;
11206 }
11207 {
11208 if (temp3)
11209 delete arg3;
11210 }
11211 {
11212 if (temp4)
11213 delete arg4;
11214 }
11215 return resultobj;
11216 fail:
11217 {
11218 if (temp2)
11219 delete arg2;
11220 }
11221 {
11222 if (temp3)
11223 delete arg3;
11224 }
11225 {
11226 if (temp4)
11227 delete arg4;
11228 }
11229 return NULL;
11230 }
11231
11232
11233 static PyObject *_wrap_Locale_Init2(PyObject *, PyObject *args, PyObject *kwargs) {
11234 PyObject *resultobj;
11235 wxLocale *arg1 = (wxLocale *) 0 ;
11236 int arg2 = (int) wxLANGUAGE_DEFAULT ;
11237 int arg3 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11238 bool result;
11239 PyObject * obj0 = 0 ;
11240 PyObject * obj1 = 0 ;
11241 PyObject * obj2 = 0 ;
11242 char *kwnames[] = {
11243 (char *) "self",(char *) "language",(char *) "flags", NULL
11244 };
11245
11246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Locale_Init2",kwnames,&obj0,&obj1,&obj2)) goto fail;
11247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11248 if (SWIG_arg_fail(1)) SWIG_fail;
11249 if (obj1) {
11250 {
11251 arg2 = (int)(SWIG_As_int(obj1));
11252 if (SWIG_arg_fail(2)) SWIG_fail;
11253 }
11254 }
11255 if (obj2) {
11256 {
11257 arg3 = (int)(SWIG_As_int(obj2));
11258 if (SWIG_arg_fail(3)) SWIG_fail;
11259 }
11260 }
11261 {
11262 PyThreadState* __tstate = wxPyBeginAllowThreads();
11263 result = (bool)wxLocale_Init2(arg1,arg2,arg3);
11264
11265 wxPyEndAllowThreads(__tstate);
11266 if (PyErr_Occurred()) SWIG_fail;
11267 }
11268 {
11269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11270 }
11271 return resultobj;
11272 fail:
11273 return NULL;
11274 }
11275
11276
11277 static PyObject *_wrap_Locale_GetSystemLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11278 PyObject *resultobj;
11279 int result;
11280 char *kwnames[] = {
11281 NULL
11282 };
11283
11284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemLanguage",kwnames)) goto fail;
11285 {
11286 PyThreadState* __tstate = wxPyBeginAllowThreads();
11287 result = (int)wxLocale::GetSystemLanguage();
11288
11289 wxPyEndAllowThreads(__tstate);
11290 if (PyErr_Occurred()) SWIG_fail;
11291 }
11292 {
11293 resultobj = SWIG_From_int((int)(result));
11294 }
11295 return resultobj;
11296 fail:
11297 return NULL;
11298 }
11299
11300
11301 static PyObject *_wrap_Locale_GetSystemEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11302 PyObject *resultobj;
11303 wxFontEncoding result;
11304 char *kwnames[] = {
11305 NULL
11306 };
11307
11308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncoding",kwnames)) goto fail;
11309 {
11310 PyThreadState* __tstate = wxPyBeginAllowThreads();
11311 result = (wxFontEncoding)wxLocale::GetSystemEncoding();
11312
11313 wxPyEndAllowThreads(__tstate);
11314 if (PyErr_Occurred()) SWIG_fail;
11315 }
11316 resultobj = SWIG_From_int((result));
11317 return resultobj;
11318 fail:
11319 return NULL;
11320 }
11321
11322
11323 static PyObject *_wrap_Locale_GetSystemEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
11324 PyObject *resultobj;
11325 wxString result;
11326 char *kwnames[] = {
11327 NULL
11328 };
11329
11330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncodingName",kwnames)) goto fail;
11331 {
11332 PyThreadState* __tstate = wxPyBeginAllowThreads();
11333 result = wxLocale::GetSystemEncodingName();
11334
11335 wxPyEndAllowThreads(__tstate);
11336 if (PyErr_Occurred()) SWIG_fail;
11337 }
11338 {
11339 #if wxUSE_UNICODE
11340 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11341 #else
11342 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11343 #endif
11344 }
11345 return resultobj;
11346 fail:
11347 return NULL;
11348 }
11349
11350
11351 static PyObject *_wrap_Locale_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11352 PyObject *resultobj;
11353 wxLocale *arg1 = (wxLocale *) 0 ;
11354 bool result;
11355 PyObject * obj0 = 0 ;
11356 char *kwnames[] = {
11357 (char *) "self", NULL
11358 };
11359
11360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_IsOk",kwnames,&obj0)) goto fail;
11361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11362 if (SWIG_arg_fail(1)) SWIG_fail;
11363 {
11364 PyThreadState* __tstate = wxPyBeginAllowThreads();
11365 result = (bool)((wxLocale const *)arg1)->IsOk();
11366
11367 wxPyEndAllowThreads(__tstate);
11368 if (PyErr_Occurred()) SWIG_fail;
11369 }
11370 {
11371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11372 }
11373 return resultobj;
11374 fail:
11375 return NULL;
11376 }
11377
11378
11379 static PyObject *_wrap_Locale_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11380 PyObject *resultobj;
11381 wxLocale *arg1 = (wxLocale *) 0 ;
11382 wxString result;
11383 PyObject * obj0 = 0 ;
11384 char *kwnames[] = {
11385 (char *) "self", NULL
11386 };
11387
11388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLocale",kwnames,&obj0)) goto fail;
11389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11390 if (SWIG_arg_fail(1)) SWIG_fail;
11391 {
11392 PyThreadState* __tstate = wxPyBeginAllowThreads();
11393 result = ((wxLocale const *)arg1)->GetLocale();
11394
11395 wxPyEndAllowThreads(__tstate);
11396 if (PyErr_Occurred()) SWIG_fail;
11397 }
11398 {
11399 #if wxUSE_UNICODE
11400 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11401 #else
11402 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11403 #endif
11404 }
11405 return resultobj;
11406 fail:
11407 return NULL;
11408 }
11409
11410
11411 static PyObject *_wrap_Locale_GetLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11412 PyObject *resultobj;
11413 wxLocale *arg1 = (wxLocale *) 0 ;
11414 int result;
11415 PyObject * obj0 = 0 ;
11416 char *kwnames[] = {
11417 (char *) "self", NULL
11418 };
11419
11420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguage",kwnames,&obj0)) goto fail;
11421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11422 if (SWIG_arg_fail(1)) SWIG_fail;
11423 {
11424 PyThreadState* __tstate = wxPyBeginAllowThreads();
11425 result = (int)((wxLocale const *)arg1)->GetLanguage();
11426
11427 wxPyEndAllowThreads(__tstate);
11428 if (PyErr_Occurred()) SWIG_fail;
11429 }
11430 {
11431 resultobj = SWIG_From_int((int)(result));
11432 }
11433 return resultobj;
11434 fail:
11435 return NULL;
11436 }
11437
11438
11439 static PyObject *_wrap_Locale_GetSysName(PyObject *, PyObject *args, PyObject *kwargs) {
11440 PyObject *resultobj;
11441 wxLocale *arg1 = (wxLocale *) 0 ;
11442 wxString result;
11443 PyObject * obj0 = 0 ;
11444 char *kwnames[] = {
11445 (char *) "self", NULL
11446 };
11447
11448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetSysName",kwnames,&obj0)) goto fail;
11449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11450 if (SWIG_arg_fail(1)) SWIG_fail;
11451 {
11452 PyThreadState* __tstate = wxPyBeginAllowThreads();
11453 result = ((wxLocale const *)arg1)->GetSysName();
11454
11455 wxPyEndAllowThreads(__tstate);
11456 if (PyErr_Occurred()) SWIG_fail;
11457 }
11458 {
11459 #if wxUSE_UNICODE
11460 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11461 #else
11462 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11463 #endif
11464 }
11465 return resultobj;
11466 fail:
11467 return NULL;
11468 }
11469
11470
11471 static PyObject *_wrap_Locale_GetCanonicalName(PyObject *, PyObject *args, PyObject *kwargs) {
11472 PyObject *resultobj;
11473 wxLocale *arg1 = (wxLocale *) 0 ;
11474 wxString result;
11475 PyObject * obj0 = 0 ;
11476 char *kwnames[] = {
11477 (char *) "self", NULL
11478 };
11479
11480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetCanonicalName",kwnames,&obj0)) goto fail;
11481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11482 if (SWIG_arg_fail(1)) SWIG_fail;
11483 {
11484 PyThreadState* __tstate = wxPyBeginAllowThreads();
11485 result = ((wxLocale const *)arg1)->GetCanonicalName();
11486
11487 wxPyEndAllowThreads(__tstate);
11488 if (PyErr_Occurred()) SWIG_fail;
11489 }
11490 {
11491 #if wxUSE_UNICODE
11492 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11493 #else
11494 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11495 #endif
11496 }
11497 return resultobj;
11498 fail:
11499 return NULL;
11500 }
11501
11502
11503 static PyObject *_wrap_Locale_AddCatalogLookupPathPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
11504 PyObject *resultobj;
11505 wxString *arg1 = 0 ;
11506 bool temp1 = false ;
11507 PyObject * obj0 = 0 ;
11508 char *kwnames[] = {
11509 (char *) "prefix", NULL
11510 };
11511
11512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddCatalogLookupPathPrefix",kwnames,&obj0)) goto fail;
11513 {
11514 arg1 = wxString_in_helper(obj0);
11515 if (arg1 == NULL) SWIG_fail;
11516 temp1 = true;
11517 }
11518 {
11519 PyThreadState* __tstate = wxPyBeginAllowThreads();
11520 wxLocale::AddCatalogLookupPathPrefix((wxString const &)*arg1);
11521
11522 wxPyEndAllowThreads(__tstate);
11523 if (PyErr_Occurred()) SWIG_fail;
11524 }
11525 Py_INCREF(Py_None); resultobj = Py_None;
11526 {
11527 if (temp1)
11528 delete arg1;
11529 }
11530 return resultobj;
11531 fail:
11532 {
11533 if (temp1)
11534 delete arg1;
11535 }
11536 return NULL;
11537 }
11538
11539
11540 static PyObject *_wrap_Locale_AddCatalog(PyObject *, PyObject *args, PyObject *kwargs) {
11541 PyObject *resultobj;
11542 wxLocale *arg1 = (wxLocale *) 0 ;
11543 wxString *arg2 = 0 ;
11544 bool result;
11545 bool temp2 = false ;
11546 PyObject * obj0 = 0 ;
11547 PyObject * obj1 = 0 ;
11548 char *kwnames[] = {
11549 (char *) "self",(char *) "szDomain", NULL
11550 };
11551
11552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_AddCatalog",kwnames,&obj0,&obj1)) goto fail;
11553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11554 if (SWIG_arg_fail(1)) SWIG_fail;
11555 {
11556 arg2 = wxString_in_helper(obj1);
11557 if (arg2 == NULL) SWIG_fail;
11558 temp2 = true;
11559 }
11560 {
11561 PyThreadState* __tstate = wxPyBeginAllowThreads();
11562 result = (bool)(arg1)->AddCatalog((wxString const &)*arg2);
11563
11564 wxPyEndAllowThreads(__tstate);
11565 if (PyErr_Occurred()) SWIG_fail;
11566 }
11567 {
11568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11569 }
11570 {
11571 if (temp2)
11572 delete arg2;
11573 }
11574 return resultobj;
11575 fail:
11576 {
11577 if (temp2)
11578 delete arg2;
11579 }
11580 return NULL;
11581 }
11582
11583
11584 static PyObject *_wrap_Locale_IsLoaded(PyObject *, PyObject *args, PyObject *kwargs) {
11585 PyObject *resultobj;
11586 wxLocale *arg1 = (wxLocale *) 0 ;
11587 wxString *arg2 = 0 ;
11588 bool result;
11589 bool temp2 = false ;
11590 PyObject * obj0 = 0 ;
11591 PyObject * obj1 = 0 ;
11592 char *kwnames[] = {
11593 (char *) "self",(char *) "szDomain", NULL
11594 };
11595
11596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_IsLoaded",kwnames,&obj0,&obj1)) goto fail;
11597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11598 if (SWIG_arg_fail(1)) SWIG_fail;
11599 {
11600 arg2 = wxString_in_helper(obj1);
11601 if (arg2 == NULL) SWIG_fail;
11602 temp2 = true;
11603 }
11604 {
11605 PyThreadState* __tstate = wxPyBeginAllowThreads();
11606 result = (bool)((wxLocale const *)arg1)->IsLoaded((wxString const &)*arg2);
11607
11608 wxPyEndAllowThreads(__tstate);
11609 if (PyErr_Occurred()) SWIG_fail;
11610 }
11611 {
11612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11613 }
11614 {
11615 if (temp2)
11616 delete arg2;
11617 }
11618 return resultobj;
11619 fail:
11620 {
11621 if (temp2)
11622 delete arg2;
11623 }
11624 return NULL;
11625 }
11626
11627
11628 static PyObject *_wrap_Locale_GetLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11629 PyObject *resultobj;
11630 int arg1 ;
11631 wxLanguageInfo *result;
11632 PyObject * obj0 = 0 ;
11633 char *kwnames[] = {
11634 (char *) "lang", NULL
11635 };
11636
11637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageInfo",kwnames,&obj0)) goto fail;
11638 {
11639 arg1 = (int)(SWIG_As_int(obj0));
11640 if (SWIG_arg_fail(1)) SWIG_fail;
11641 }
11642 {
11643 PyThreadState* __tstate = wxPyBeginAllowThreads();
11644 result = (wxLanguageInfo *)wxLocale::GetLanguageInfo(arg1);
11645
11646 wxPyEndAllowThreads(__tstate);
11647 if (PyErr_Occurred()) SWIG_fail;
11648 }
11649 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
11650 return resultobj;
11651 fail:
11652 return NULL;
11653 }
11654
11655
11656 static PyObject *_wrap_Locale_GetLanguageName(PyObject *, PyObject *args, PyObject *kwargs) {
11657 PyObject *resultobj;
11658 int arg1 ;
11659 wxString result;
11660 PyObject * obj0 = 0 ;
11661 char *kwnames[] = {
11662 (char *) "lang", NULL
11663 };
11664
11665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageName",kwnames,&obj0)) goto fail;
11666 {
11667 arg1 = (int)(SWIG_As_int(obj0));
11668 if (SWIG_arg_fail(1)) SWIG_fail;
11669 }
11670 {
11671 PyThreadState* __tstate = wxPyBeginAllowThreads();
11672 result = wxLocale::GetLanguageName(arg1);
11673
11674 wxPyEndAllowThreads(__tstate);
11675 if (PyErr_Occurred()) SWIG_fail;
11676 }
11677 {
11678 #if wxUSE_UNICODE
11679 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11680 #else
11681 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11682 #endif
11683 }
11684 return resultobj;
11685 fail:
11686 return NULL;
11687 }
11688
11689
11690 static PyObject *_wrap_Locale_FindLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11691 PyObject *resultobj;
11692 wxString *arg1 = 0 ;
11693 wxLanguageInfo *result;
11694 bool temp1 = false ;
11695 PyObject * obj0 = 0 ;
11696 char *kwnames[] = {
11697 (char *) "locale", NULL
11698 };
11699
11700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_FindLanguageInfo",kwnames,&obj0)) goto fail;
11701 {
11702 arg1 = wxString_in_helper(obj0);
11703 if (arg1 == NULL) SWIG_fail;
11704 temp1 = true;
11705 }
11706 {
11707 PyThreadState* __tstate = wxPyBeginAllowThreads();
11708 result = (wxLanguageInfo *)wxLocale::FindLanguageInfo((wxString const &)*arg1);
11709
11710 wxPyEndAllowThreads(__tstate);
11711 if (PyErr_Occurred()) SWIG_fail;
11712 }
11713 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
11714 {
11715 if (temp1)
11716 delete arg1;
11717 }
11718 return resultobj;
11719 fail:
11720 {
11721 if (temp1)
11722 delete arg1;
11723 }
11724 return NULL;
11725 }
11726
11727
11728 static PyObject *_wrap_Locale_AddLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11729 PyObject *resultobj;
11730 wxLanguageInfo *arg1 = 0 ;
11731 PyObject * obj0 = 0 ;
11732 char *kwnames[] = {
11733 (char *) "info", NULL
11734 };
11735
11736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddLanguage",kwnames,&obj0)) goto fail;
11737 {
11738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11739 if (SWIG_arg_fail(1)) SWIG_fail;
11740 if (arg1 == NULL) {
11741 SWIG_null_ref("wxLanguageInfo");
11742 }
11743 if (SWIG_arg_fail(1)) SWIG_fail;
11744 }
11745 {
11746 PyThreadState* __tstate = wxPyBeginAllowThreads();
11747 wxLocale::AddLanguage((wxLanguageInfo const &)*arg1);
11748
11749 wxPyEndAllowThreads(__tstate);
11750 if (PyErr_Occurred()) SWIG_fail;
11751 }
11752 Py_INCREF(Py_None); resultobj = Py_None;
11753 return resultobj;
11754 fail:
11755 return NULL;
11756 }
11757
11758
11759 static PyObject *_wrap_Locale_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
11760 PyObject *resultobj;
11761 wxLocale *arg1 = (wxLocale *) 0 ;
11762 wxString *arg2 = 0 ;
11763 wxString const &arg3_defvalue = wxPyEmptyString ;
11764 wxString *arg3 = (wxString *) &arg3_defvalue ;
11765 wxString result;
11766 bool temp2 = false ;
11767 bool temp3 = false ;
11768 PyObject * obj0 = 0 ;
11769 PyObject * obj1 = 0 ;
11770 PyObject * obj2 = 0 ;
11771 char *kwnames[] = {
11772 (char *) "self",(char *) "szOrigString",(char *) "szDomain", NULL
11773 };
11774
11775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Locale_GetString",kwnames,&obj0,&obj1,&obj2)) 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 {
11791 PyThreadState* __tstate = wxPyBeginAllowThreads();
11792 result = ((wxLocale const *)arg1)->GetString((wxString const &)*arg2,(wxString const &)*arg3);
11793
11794 wxPyEndAllowThreads(__tstate);
11795 if (PyErr_Occurred()) SWIG_fail;
11796 }
11797 {
11798 #if wxUSE_UNICODE
11799 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11800 #else
11801 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11802 #endif
11803 }
11804 {
11805 if (temp2)
11806 delete arg2;
11807 }
11808 {
11809 if (temp3)
11810 delete arg3;
11811 }
11812 return resultobj;
11813 fail:
11814 {
11815 if (temp2)
11816 delete arg2;
11817 }
11818 {
11819 if (temp3)
11820 delete arg3;
11821 }
11822 return NULL;
11823 }
11824
11825
11826 static PyObject *_wrap_Locale_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
11827 PyObject *resultobj;
11828 wxLocale *arg1 = (wxLocale *) 0 ;
11829 wxString *result;
11830 PyObject * obj0 = 0 ;
11831 char *kwnames[] = {
11832 (char *) "self", NULL
11833 };
11834
11835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetName",kwnames,&obj0)) goto fail;
11836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11837 if (SWIG_arg_fail(1)) SWIG_fail;
11838 {
11839 PyThreadState* __tstate = wxPyBeginAllowThreads();
11840 {
11841 wxString const &_result_ref = ((wxLocale const *)arg1)->GetName();
11842 result = (wxString *) &_result_ref;
11843 }
11844
11845 wxPyEndAllowThreads(__tstate);
11846 if (PyErr_Occurred()) SWIG_fail;
11847 }
11848 {
11849 #if wxUSE_UNICODE
11850 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11851 #else
11852 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11853 #endif
11854 }
11855 return resultobj;
11856 fail:
11857 return NULL;
11858 }
11859
11860
11861 static PyObject * Locale_swigregister(PyObject *, PyObject *args) {
11862 PyObject *obj;
11863 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11864 SWIG_TypeClientData(SWIGTYPE_p_wxLocale, obj);
11865 Py_INCREF(obj);
11866 return Py_BuildValue((char *)"");
11867 }
11868 static PyObject *_wrap_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11869 PyObject *resultobj;
11870 wxLocale *result;
11871 char *kwnames[] = {
11872 NULL
11873 };
11874
11875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocale",kwnames)) goto fail;
11876 {
11877 PyThreadState* __tstate = wxPyBeginAllowThreads();
11878 result = (wxLocale *)wxGetLocale();
11879
11880 wxPyEndAllowThreads(__tstate);
11881 if (PyErr_Occurred()) SWIG_fail;
11882 }
11883 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 0);
11884 return resultobj;
11885 fail:
11886 return NULL;
11887 }
11888
11889
11890 static PyObject *_wrap_GetTranslation__SWIG_0(PyObject *, PyObject *args) {
11891 PyObject *resultobj;
11892 wxString *arg1 = 0 ;
11893 wxString result;
11894 bool temp1 = false ;
11895 PyObject * obj0 = 0 ;
11896
11897 if(!PyArg_ParseTuple(args,(char *)"O:GetTranslation",&obj0)) goto fail;
11898 {
11899 arg1 = wxString_in_helper(obj0);
11900 if (arg1 == NULL) SWIG_fail;
11901 temp1 = true;
11902 }
11903 {
11904 PyThreadState* __tstate = wxPyBeginAllowThreads();
11905 result = wxGetTranslation((wxString const &)*arg1);
11906
11907 wxPyEndAllowThreads(__tstate);
11908 if (PyErr_Occurred()) SWIG_fail;
11909 }
11910 {
11911 #if wxUSE_UNICODE
11912 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11913 #else
11914 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11915 #endif
11916 }
11917 {
11918 if (temp1)
11919 delete arg1;
11920 }
11921 return resultobj;
11922 fail:
11923 {
11924 if (temp1)
11925 delete arg1;
11926 }
11927 return NULL;
11928 }
11929
11930
11931 static PyObject *_wrap_GetTranslation__SWIG_1(PyObject *, PyObject *args) {
11932 PyObject *resultobj;
11933 wxString *arg1 = 0 ;
11934 wxString *arg2 = 0 ;
11935 size_t arg3 ;
11936 wxString result;
11937 bool temp1 = false ;
11938 bool temp2 = false ;
11939 PyObject * obj0 = 0 ;
11940 PyObject * obj1 = 0 ;
11941 PyObject * obj2 = 0 ;
11942
11943 if(!PyArg_ParseTuple(args,(char *)"OOO:GetTranslation",&obj0,&obj1,&obj2)) goto fail;
11944 {
11945 arg1 = wxString_in_helper(obj0);
11946 if (arg1 == NULL) SWIG_fail;
11947 temp1 = true;
11948 }
11949 {
11950 arg2 = wxString_in_helper(obj1);
11951 if (arg2 == NULL) SWIG_fail;
11952 temp2 = true;
11953 }
11954 {
11955 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
11956 if (SWIG_arg_fail(3)) SWIG_fail;
11957 }
11958 {
11959 PyThreadState* __tstate = wxPyBeginAllowThreads();
11960 result = wxGetTranslation((wxString const &)*arg1,(wxString const &)*arg2,arg3);
11961
11962 wxPyEndAllowThreads(__tstate);
11963 if (PyErr_Occurred()) SWIG_fail;
11964 }
11965 {
11966 #if wxUSE_UNICODE
11967 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11968 #else
11969 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11970 #endif
11971 }
11972 {
11973 if (temp1)
11974 delete arg1;
11975 }
11976 {
11977 if (temp2)
11978 delete arg2;
11979 }
11980 return resultobj;
11981 fail:
11982 {
11983 if (temp1)
11984 delete arg1;
11985 }
11986 {
11987 if (temp2)
11988 delete arg2;
11989 }
11990 return NULL;
11991 }
11992
11993
11994 static PyObject *_wrap_GetTranslation(PyObject *self, PyObject *args) {
11995 int argc;
11996 PyObject *argv[4];
11997 int ii;
11998
11999 argc = PyObject_Length(args);
12000 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
12001 argv[ii] = PyTuple_GetItem(args,ii);
12002 }
12003 if (argc == 1) {
12004 int _v;
12005 {
12006 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12007 }
12008 if (_v) {
12009 return _wrap_GetTranslation__SWIG_0(self,args);
12010 }
12011 }
12012 if (argc == 3) {
12013 int _v;
12014 {
12015 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12016 }
12017 if (_v) {
12018 {
12019 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
12020 }
12021 if (_v) {
12022 _v = SWIG_Check_unsigned_SS_long(argv[2]);
12023 if (_v) {
12024 return _wrap_GetTranslation__SWIG_1(self,args);
12025 }
12026 }
12027 }
12028 }
12029
12030 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GetTranslation'");
12031 return NULL;
12032 }
12033
12034
12035 static PyObject *_wrap_new_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
12036 PyObject *resultobj;
12037 wxEncodingConverter *result;
12038 char *kwnames[] = {
12039 NULL
12040 };
12041
12042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EncodingConverter",kwnames)) goto fail;
12043 {
12044 PyThreadState* __tstate = wxPyBeginAllowThreads();
12045 result = (wxEncodingConverter *)new wxEncodingConverter();
12046
12047 wxPyEndAllowThreads(__tstate);
12048 if (PyErr_Occurred()) SWIG_fail;
12049 }
12050 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEncodingConverter, 1);
12051 return resultobj;
12052 fail:
12053 return NULL;
12054 }
12055
12056
12057 static PyObject *_wrap_delete_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
12058 PyObject *resultobj;
12059 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12060 PyObject * obj0 = 0 ;
12061 char *kwnames[] = {
12062 (char *) "self", NULL
12063 };
12064
12065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EncodingConverter",kwnames,&obj0)) goto fail;
12066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12067 if (SWIG_arg_fail(1)) SWIG_fail;
12068 {
12069 PyThreadState* __tstate = wxPyBeginAllowThreads();
12070 delete arg1;
12071
12072 wxPyEndAllowThreads(__tstate);
12073 if (PyErr_Occurred()) SWIG_fail;
12074 }
12075 Py_INCREF(Py_None); resultobj = Py_None;
12076 return resultobj;
12077 fail:
12078 return NULL;
12079 }
12080
12081
12082 static PyObject *_wrap_EncodingConverter_Init(PyObject *, PyObject *args, PyObject *kwargs) {
12083 PyObject *resultobj;
12084 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12085 wxFontEncoding arg2 ;
12086 wxFontEncoding arg3 ;
12087 int arg4 = (int) wxCONVERT_STRICT ;
12088 bool result;
12089 PyObject * obj0 = 0 ;
12090 PyObject * obj1 = 0 ;
12091 PyObject * obj2 = 0 ;
12092 PyObject * obj3 = 0 ;
12093 char *kwnames[] = {
12094 (char *) "self",(char *) "input_enc",(char *) "output_enc",(char *) "method", NULL
12095 };
12096
12097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:EncodingConverter_Init",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12099 if (SWIG_arg_fail(1)) SWIG_fail;
12100 {
12101 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12102 if (SWIG_arg_fail(2)) SWIG_fail;
12103 }
12104 {
12105 arg3 = (wxFontEncoding)(SWIG_As_int(obj2));
12106 if (SWIG_arg_fail(3)) SWIG_fail;
12107 }
12108 if (obj3) {
12109 {
12110 arg4 = (int)(SWIG_As_int(obj3));
12111 if (SWIG_arg_fail(4)) SWIG_fail;
12112 }
12113 }
12114 {
12115 PyThreadState* __tstate = wxPyBeginAllowThreads();
12116 result = (bool)(arg1)->Init((wxFontEncoding )arg2,(wxFontEncoding )arg3,arg4);
12117
12118 wxPyEndAllowThreads(__tstate);
12119 if (PyErr_Occurred()) SWIG_fail;
12120 }
12121 {
12122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12123 }
12124 return resultobj;
12125 fail:
12126 return NULL;
12127 }
12128
12129
12130 static PyObject *_wrap_EncodingConverter_Convert(PyObject *, PyObject *args, PyObject *kwargs) {
12131 PyObject *resultobj;
12132 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12133 wxString *arg2 = 0 ;
12134 wxString result;
12135 bool temp2 = false ;
12136 PyObject * obj0 = 0 ;
12137 PyObject * obj1 = 0 ;
12138 char *kwnames[] = {
12139 (char *) "self",(char *) "input", NULL
12140 };
12141
12142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_Convert",kwnames,&obj0,&obj1)) goto fail;
12143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12144 if (SWIG_arg_fail(1)) SWIG_fail;
12145 {
12146 arg2 = wxString_in_helper(obj1);
12147 if (arg2 == NULL) SWIG_fail;
12148 temp2 = true;
12149 }
12150 {
12151 PyThreadState* __tstate = wxPyBeginAllowThreads();
12152 result = (arg1)->Convert((wxString const &)*arg2);
12153
12154 wxPyEndAllowThreads(__tstate);
12155 if (PyErr_Occurred()) SWIG_fail;
12156 }
12157 {
12158 #if wxUSE_UNICODE
12159 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12160 #else
12161 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12162 #endif
12163 }
12164 {
12165 if (temp2)
12166 delete arg2;
12167 }
12168 return resultobj;
12169 fail:
12170 {
12171 if (temp2)
12172 delete arg2;
12173 }
12174 return NULL;
12175 }
12176
12177
12178 static PyObject *_wrap_EncodingConverter_GetPlatformEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12179 PyObject *resultobj;
12180 wxFontEncoding arg1 ;
12181 int arg2 = (int) wxPLATFORM_CURRENT ;
12182 wxFontEncodingArray result;
12183 PyObject * obj0 = 0 ;
12184 PyObject * obj1 = 0 ;
12185 char *kwnames[] = {
12186 (char *) "enc",(char *) "platform", NULL
12187 };
12188
12189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EncodingConverter_GetPlatformEquivalents",kwnames,&obj0,&obj1)) goto fail;
12190 {
12191 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12192 if (SWIG_arg_fail(1)) SWIG_fail;
12193 }
12194 if (obj1) {
12195 {
12196 arg2 = (int)(SWIG_As_int(obj1));
12197 if (SWIG_arg_fail(2)) SWIG_fail;
12198 }
12199 }
12200 {
12201 PyThreadState* __tstate = wxPyBeginAllowThreads();
12202 result = wxEncodingConverter::GetPlatformEquivalents((wxFontEncoding )arg1,arg2);
12203
12204 wxPyEndAllowThreads(__tstate);
12205 if (PyErr_Occurred()) SWIG_fail;
12206 }
12207 {
12208 resultobj = PyList_New(0);
12209 for (size_t i=0; i < (&result)->GetCount(); i++) {
12210 PyObject* number = PyInt_FromLong((&result)->Item(i));
12211 PyList_Append(resultobj, number);
12212 Py_DECREF(number);
12213 }
12214 }
12215 return resultobj;
12216 fail:
12217 return NULL;
12218 }
12219
12220
12221 static PyObject *_wrap_EncodingConverter_GetAllEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12222 PyObject *resultobj;
12223 wxFontEncoding arg1 ;
12224 wxFontEncodingArray result;
12225 PyObject * obj0 = 0 ;
12226 char *kwnames[] = {
12227 (char *) "enc", NULL
12228 };
12229
12230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EncodingConverter_GetAllEquivalents",kwnames,&obj0)) goto fail;
12231 {
12232 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12233 if (SWIG_arg_fail(1)) SWIG_fail;
12234 }
12235 {
12236 PyThreadState* __tstate = wxPyBeginAllowThreads();
12237 result = wxEncodingConverter::GetAllEquivalents((wxFontEncoding )arg1);
12238
12239 wxPyEndAllowThreads(__tstate);
12240 if (PyErr_Occurred()) SWIG_fail;
12241 }
12242 {
12243 resultobj = PyList_New(0);
12244 for (size_t i=0; i < (&result)->GetCount(); i++) {
12245 PyObject* number = PyInt_FromLong((&result)->Item(i));
12246 PyList_Append(resultobj, number);
12247 Py_DECREF(number);
12248 }
12249 }
12250 return resultobj;
12251 fail:
12252 return NULL;
12253 }
12254
12255
12256 static PyObject *_wrap_EncodingConverter_CanConvert(PyObject *, PyObject *args, PyObject *kwargs) {
12257 PyObject *resultobj;
12258 wxFontEncoding arg1 ;
12259 wxFontEncoding arg2 ;
12260 bool result;
12261 PyObject * obj0 = 0 ;
12262 PyObject * obj1 = 0 ;
12263 char *kwnames[] = {
12264 (char *) "encIn",(char *) "encOut", NULL
12265 };
12266
12267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_CanConvert",kwnames,&obj0,&obj1)) goto fail;
12268 {
12269 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12270 if (SWIG_arg_fail(1)) SWIG_fail;
12271 }
12272 {
12273 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12274 if (SWIG_arg_fail(2)) SWIG_fail;
12275 }
12276 {
12277 PyThreadState* __tstate = wxPyBeginAllowThreads();
12278 result = (bool)wxEncodingConverter::CanConvert((wxFontEncoding )arg1,(wxFontEncoding )arg2);
12279
12280 wxPyEndAllowThreads(__tstate);
12281 if (PyErr_Occurred()) SWIG_fail;
12282 }
12283 {
12284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12285 }
12286 return resultobj;
12287 fail:
12288 return NULL;
12289 }
12290
12291
12292 static PyObject * EncodingConverter_swigregister(PyObject *, PyObject *args) {
12293 PyObject *obj;
12294 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12295 SWIG_TypeClientData(SWIGTYPE_p_wxEncodingConverter, obj);
12296 Py_INCREF(obj);
12297 return Py_BuildValue((char *)"");
12298 }
12299 static PyObject *_wrap_delete_DC(PyObject *, PyObject *args, PyObject *kwargs) {
12300 PyObject *resultobj;
12301 wxDC *arg1 = (wxDC *) 0 ;
12302 PyObject * obj0 = 0 ;
12303 char *kwnames[] = {
12304 (char *) "self", NULL
12305 };
12306
12307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DC",kwnames,&obj0)) goto fail;
12308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12309 if (SWIG_arg_fail(1)) SWIG_fail;
12310 {
12311 PyThreadState* __tstate = wxPyBeginAllowThreads();
12312 delete arg1;
12313
12314 wxPyEndAllowThreads(__tstate);
12315 if (PyErr_Occurred()) SWIG_fail;
12316 }
12317 Py_INCREF(Py_None); resultobj = Py_None;
12318 return resultobj;
12319 fail:
12320 return NULL;
12321 }
12322
12323
12324 static PyObject *_wrap_DC_BeginDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12325 PyObject *resultobj;
12326 wxDC *arg1 = (wxDC *) 0 ;
12327 PyObject * obj0 = 0 ;
12328 char *kwnames[] = {
12329 (char *) "self", NULL
12330 };
12331
12332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_BeginDrawing",kwnames,&obj0)) goto fail;
12333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12334 if (SWIG_arg_fail(1)) SWIG_fail;
12335 {
12336 PyThreadState* __tstate = wxPyBeginAllowThreads();
12337 (arg1)->BeginDrawing();
12338
12339 wxPyEndAllowThreads(__tstate);
12340 if (PyErr_Occurred()) SWIG_fail;
12341 }
12342 Py_INCREF(Py_None); resultobj = Py_None;
12343 return resultobj;
12344 fail:
12345 return NULL;
12346 }
12347
12348
12349 static PyObject *_wrap_DC_EndDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12350 PyObject *resultobj;
12351 wxDC *arg1 = (wxDC *) 0 ;
12352 PyObject * obj0 = 0 ;
12353 char *kwnames[] = {
12354 (char *) "self", NULL
12355 };
12356
12357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDrawing",kwnames,&obj0)) goto fail;
12358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12359 if (SWIG_arg_fail(1)) SWIG_fail;
12360 {
12361 PyThreadState* __tstate = wxPyBeginAllowThreads();
12362 (arg1)->EndDrawing();
12363
12364 wxPyEndAllowThreads(__tstate);
12365 if (PyErr_Occurred()) SWIG_fail;
12366 }
12367 Py_INCREF(Py_None); resultobj = Py_None;
12368 return resultobj;
12369 fail:
12370 return NULL;
12371 }
12372
12373
12374 static PyObject *_wrap_DC_FloodFill(PyObject *, PyObject *args, PyObject *kwargs) {
12375 PyObject *resultobj;
12376 wxDC *arg1 = (wxDC *) 0 ;
12377 int arg2 ;
12378 int arg3 ;
12379 wxColour *arg4 = 0 ;
12380 int arg5 = (int) wxFLOOD_SURFACE ;
12381 bool result;
12382 wxColour temp4 ;
12383 PyObject * obj0 = 0 ;
12384 PyObject * obj1 = 0 ;
12385 PyObject * obj2 = 0 ;
12386 PyObject * obj3 = 0 ;
12387 PyObject * obj4 = 0 ;
12388 char *kwnames[] = {
12389 (char *) "self",(char *) "x",(char *) "y",(char *) "col",(char *) "style", NULL
12390 };
12391
12392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_FloodFill",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12394 if (SWIG_arg_fail(1)) SWIG_fail;
12395 {
12396 arg2 = (int)(SWIG_As_int(obj1));
12397 if (SWIG_arg_fail(2)) SWIG_fail;
12398 }
12399 {
12400 arg3 = (int)(SWIG_As_int(obj2));
12401 if (SWIG_arg_fail(3)) SWIG_fail;
12402 }
12403 {
12404 arg4 = &temp4;
12405 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
12406 }
12407 if (obj4) {
12408 {
12409 arg5 = (int)(SWIG_As_int(obj4));
12410 if (SWIG_arg_fail(5)) SWIG_fail;
12411 }
12412 }
12413 {
12414 PyThreadState* __tstate = wxPyBeginAllowThreads();
12415 result = (bool)(arg1)->FloodFill(arg2,arg3,(wxColour const &)*arg4,arg5);
12416
12417 wxPyEndAllowThreads(__tstate);
12418 if (PyErr_Occurred()) SWIG_fail;
12419 }
12420 {
12421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12422 }
12423 return resultobj;
12424 fail:
12425 return NULL;
12426 }
12427
12428
12429 static PyObject *_wrap_DC_FloodFillPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12430 PyObject *resultobj;
12431 wxDC *arg1 = (wxDC *) 0 ;
12432 wxPoint *arg2 = 0 ;
12433 wxColour *arg3 = 0 ;
12434 int arg4 = (int) wxFLOOD_SURFACE ;
12435 bool result;
12436 wxPoint temp2 ;
12437 wxColour temp3 ;
12438 PyObject * obj0 = 0 ;
12439 PyObject * obj1 = 0 ;
12440 PyObject * obj2 = 0 ;
12441 PyObject * obj3 = 0 ;
12442 char *kwnames[] = {
12443 (char *) "self",(char *) "pt",(char *) "col",(char *) "style", NULL
12444 };
12445
12446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_FloodFillPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12448 if (SWIG_arg_fail(1)) SWIG_fail;
12449 {
12450 arg2 = &temp2;
12451 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12452 }
12453 {
12454 arg3 = &temp3;
12455 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
12456 }
12457 if (obj3) {
12458 {
12459 arg4 = (int)(SWIG_As_int(obj3));
12460 if (SWIG_arg_fail(4)) SWIG_fail;
12461 }
12462 }
12463 {
12464 PyThreadState* __tstate = wxPyBeginAllowThreads();
12465 result = (bool)(arg1)->FloodFill((wxPoint const &)*arg2,(wxColour const &)*arg3,arg4);
12466
12467 wxPyEndAllowThreads(__tstate);
12468 if (PyErr_Occurred()) SWIG_fail;
12469 }
12470 {
12471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12472 }
12473 return resultobj;
12474 fail:
12475 return NULL;
12476 }
12477
12478
12479 static PyObject *_wrap_DC_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
12480 PyObject *resultobj;
12481 wxDC *arg1 = (wxDC *) 0 ;
12482 int arg2 ;
12483 int arg3 ;
12484 wxColour result;
12485 PyObject * obj0 = 0 ;
12486 PyObject * obj1 = 0 ;
12487 PyObject * obj2 = 0 ;
12488 char *kwnames[] = {
12489 (char *) "self",(char *) "x",(char *) "y", NULL
12490 };
12491
12492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_GetPixel",kwnames,&obj0,&obj1,&obj2)) goto fail;
12493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12494 if (SWIG_arg_fail(1)) SWIG_fail;
12495 {
12496 arg2 = (int)(SWIG_As_int(obj1));
12497 if (SWIG_arg_fail(2)) SWIG_fail;
12498 }
12499 {
12500 arg3 = (int)(SWIG_As_int(obj2));
12501 if (SWIG_arg_fail(3)) SWIG_fail;
12502 }
12503 {
12504 PyThreadState* __tstate = wxPyBeginAllowThreads();
12505 result = wxDC_GetPixel(arg1,arg2,arg3);
12506
12507 wxPyEndAllowThreads(__tstate);
12508 if (PyErr_Occurred()) SWIG_fail;
12509 }
12510 {
12511 wxColour * resultptr;
12512 resultptr = new wxColour((wxColour &)(result));
12513 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12514 }
12515 return resultobj;
12516 fail:
12517 return NULL;
12518 }
12519
12520
12521 static PyObject *_wrap_DC_GetPixelPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12522 PyObject *resultobj;
12523 wxDC *arg1 = (wxDC *) 0 ;
12524 wxPoint *arg2 = 0 ;
12525 wxColour result;
12526 wxPoint temp2 ;
12527 PyObject * obj0 = 0 ;
12528 PyObject * obj1 = 0 ;
12529 char *kwnames[] = {
12530 (char *) "self",(char *) "pt", NULL
12531 };
12532
12533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPixelPoint",kwnames,&obj0,&obj1)) goto fail;
12534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12535 if (SWIG_arg_fail(1)) SWIG_fail;
12536 {
12537 arg2 = &temp2;
12538 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12539 }
12540 {
12541 PyThreadState* __tstate = wxPyBeginAllowThreads();
12542 result = wxDC_GetPixelPoint(arg1,(wxPoint const &)*arg2);
12543
12544 wxPyEndAllowThreads(__tstate);
12545 if (PyErr_Occurred()) SWIG_fail;
12546 }
12547 {
12548 wxColour * resultptr;
12549 resultptr = new wxColour((wxColour &)(result));
12550 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12551 }
12552 return resultobj;
12553 fail:
12554 return NULL;
12555 }
12556
12557
12558 static PyObject *_wrap_DC_DrawLine(PyObject *, PyObject *args, PyObject *kwargs) {
12559 PyObject *resultobj;
12560 wxDC *arg1 = (wxDC *) 0 ;
12561 int arg2 ;
12562 int arg3 ;
12563 int arg4 ;
12564 int arg5 ;
12565 PyObject * obj0 = 0 ;
12566 PyObject * obj1 = 0 ;
12567 PyObject * obj2 = 0 ;
12568 PyObject * obj3 = 0 ;
12569 PyObject * obj4 = 0 ;
12570 char *kwnames[] = {
12571 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2", NULL
12572 };
12573
12574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12576 if (SWIG_arg_fail(1)) SWIG_fail;
12577 {
12578 arg2 = (int)(SWIG_As_int(obj1));
12579 if (SWIG_arg_fail(2)) SWIG_fail;
12580 }
12581 {
12582 arg3 = (int)(SWIG_As_int(obj2));
12583 if (SWIG_arg_fail(3)) SWIG_fail;
12584 }
12585 {
12586 arg4 = (int)(SWIG_As_int(obj3));
12587 if (SWIG_arg_fail(4)) SWIG_fail;
12588 }
12589 {
12590 arg5 = (int)(SWIG_As_int(obj4));
12591 if (SWIG_arg_fail(5)) SWIG_fail;
12592 }
12593 {
12594 PyThreadState* __tstate = wxPyBeginAllowThreads();
12595 (arg1)->DrawLine(arg2,arg3,arg4,arg5);
12596
12597 wxPyEndAllowThreads(__tstate);
12598 if (PyErr_Occurred()) SWIG_fail;
12599 }
12600 Py_INCREF(Py_None); resultobj = Py_None;
12601 return resultobj;
12602 fail:
12603 return NULL;
12604 }
12605
12606
12607 static PyObject *_wrap_DC_DrawLinePoint(PyObject *, PyObject *args, PyObject *kwargs) {
12608 PyObject *resultobj;
12609 wxDC *arg1 = (wxDC *) 0 ;
12610 wxPoint *arg2 = 0 ;
12611 wxPoint *arg3 = 0 ;
12612 wxPoint temp2 ;
12613 wxPoint temp3 ;
12614 PyObject * obj0 = 0 ;
12615 PyObject * obj1 = 0 ;
12616 PyObject * obj2 = 0 ;
12617 char *kwnames[] = {
12618 (char *) "self",(char *) "pt1",(char *) "pt2", NULL
12619 };
12620
12621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawLinePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
12622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12623 if (SWIG_arg_fail(1)) SWIG_fail;
12624 {
12625 arg2 = &temp2;
12626 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12627 }
12628 {
12629 arg3 = &temp3;
12630 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12631 }
12632 {
12633 PyThreadState* __tstate = wxPyBeginAllowThreads();
12634 (arg1)->DrawLine((wxPoint const &)*arg2,(wxPoint const &)*arg3);
12635
12636 wxPyEndAllowThreads(__tstate);
12637 if (PyErr_Occurred()) SWIG_fail;
12638 }
12639 Py_INCREF(Py_None); resultobj = Py_None;
12640 return resultobj;
12641 fail:
12642 return NULL;
12643 }
12644
12645
12646 static PyObject *_wrap_DC_CrossHair(PyObject *, PyObject *args, PyObject *kwargs) {
12647 PyObject *resultobj;
12648 wxDC *arg1 = (wxDC *) 0 ;
12649 int arg2 ;
12650 int arg3 ;
12651 PyObject * obj0 = 0 ;
12652 PyObject * obj1 = 0 ;
12653 PyObject * obj2 = 0 ;
12654 char *kwnames[] = {
12655 (char *) "self",(char *) "x",(char *) "y", NULL
12656 };
12657
12658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CrossHair",kwnames,&obj0,&obj1,&obj2)) goto fail;
12659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12660 if (SWIG_arg_fail(1)) SWIG_fail;
12661 {
12662 arg2 = (int)(SWIG_As_int(obj1));
12663 if (SWIG_arg_fail(2)) SWIG_fail;
12664 }
12665 {
12666 arg3 = (int)(SWIG_As_int(obj2));
12667 if (SWIG_arg_fail(3)) SWIG_fail;
12668 }
12669 {
12670 PyThreadState* __tstate = wxPyBeginAllowThreads();
12671 (arg1)->CrossHair(arg2,arg3);
12672
12673 wxPyEndAllowThreads(__tstate);
12674 if (PyErr_Occurred()) SWIG_fail;
12675 }
12676 Py_INCREF(Py_None); resultobj = Py_None;
12677 return resultobj;
12678 fail:
12679 return NULL;
12680 }
12681
12682
12683 static PyObject *_wrap_DC_CrossHairPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12684 PyObject *resultobj;
12685 wxDC *arg1 = (wxDC *) 0 ;
12686 wxPoint *arg2 = 0 ;
12687 wxPoint temp2 ;
12688 PyObject * obj0 = 0 ;
12689 PyObject * obj1 = 0 ;
12690 char *kwnames[] = {
12691 (char *) "self",(char *) "pt", NULL
12692 };
12693
12694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CrossHairPoint",kwnames,&obj0,&obj1)) goto fail;
12695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12696 if (SWIG_arg_fail(1)) SWIG_fail;
12697 {
12698 arg2 = &temp2;
12699 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12700 }
12701 {
12702 PyThreadState* __tstate = wxPyBeginAllowThreads();
12703 (arg1)->CrossHair((wxPoint const &)*arg2);
12704
12705 wxPyEndAllowThreads(__tstate);
12706 if (PyErr_Occurred()) SWIG_fail;
12707 }
12708 Py_INCREF(Py_None); resultobj = Py_None;
12709 return resultobj;
12710 fail:
12711 return NULL;
12712 }
12713
12714
12715 static PyObject *_wrap_DC_DrawArc(PyObject *, PyObject *args, PyObject *kwargs) {
12716 PyObject *resultobj;
12717 wxDC *arg1 = (wxDC *) 0 ;
12718 int arg2 ;
12719 int arg3 ;
12720 int arg4 ;
12721 int arg5 ;
12722 int arg6 ;
12723 int arg7 ;
12724 PyObject * obj0 = 0 ;
12725 PyObject * obj1 = 0 ;
12726 PyObject * obj2 = 0 ;
12727 PyObject * obj3 = 0 ;
12728 PyObject * obj4 = 0 ;
12729 PyObject * obj5 = 0 ;
12730 PyObject * obj6 = 0 ;
12731 char *kwnames[] = {
12732 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2",(char *) "xc",(char *) "yc", NULL
12733 };
12734
12735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12737 if (SWIG_arg_fail(1)) SWIG_fail;
12738 {
12739 arg2 = (int)(SWIG_As_int(obj1));
12740 if (SWIG_arg_fail(2)) SWIG_fail;
12741 }
12742 {
12743 arg3 = (int)(SWIG_As_int(obj2));
12744 if (SWIG_arg_fail(3)) SWIG_fail;
12745 }
12746 {
12747 arg4 = (int)(SWIG_As_int(obj3));
12748 if (SWIG_arg_fail(4)) SWIG_fail;
12749 }
12750 {
12751 arg5 = (int)(SWIG_As_int(obj4));
12752 if (SWIG_arg_fail(5)) SWIG_fail;
12753 }
12754 {
12755 arg6 = (int)(SWIG_As_int(obj5));
12756 if (SWIG_arg_fail(6)) SWIG_fail;
12757 }
12758 {
12759 arg7 = (int)(SWIG_As_int(obj6));
12760 if (SWIG_arg_fail(7)) SWIG_fail;
12761 }
12762 {
12763 PyThreadState* __tstate = wxPyBeginAllowThreads();
12764 (arg1)->DrawArc(arg2,arg3,arg4,arg5,arg6,arg7);
12765
12766 wxPyEndAllowThreads(__tstate);
12767 if (PyErr_Occurred()) SWIG_fail;
12768 }
12769 Py_INCREF(Py_None); resultobj = Py_None;
12770 return resultobj;
12771 fail:
12772 return NULL;
12773 }
12774
12775
12776 static PyObject *_wrap_DC_DrawArcPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12777 PyObject *resultobj;
12778 wxDC *arg1 = (wxDC *) 0 ;
12779 wxPoint *arg2 = 0 ;
12780 wxPoint *arg3 = 0 ;
12781 wxPoint *arg4 = 0 ;
12782 wxPoint temp2 ;
12783 wxPoint temp3 ;
12784 wxPoint temp4 ;
12785 PyObject * obj0 = 0 ;
12786 PyObject * obj1 = 0 ;
12787 PyObject * obj2 = 0 ;
12788 PyObject * obj3 = 0 ;
12789 char *kwnames[] = {
12790 (char *) "self",(char *) "pt1",(char *) "pt2",(char *) "center", NULL
12791 };
12792
12793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawArcPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12795 if (SWIG_arg_fail(1)) SWIG_fail;
12796 {
12797 arg2 = &temp2;
12798 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12799 }
12800 {
12801 arg3 = &temp3;
12802 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12803 }
12804 {
12805 arg4 = &temp4;
12806 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
12807 }
12808 {
12809 PyThreadState* __tstate = wxPyBeginAllowThreads();
12810 (arg1)->DrawArc((wxPoint const &)*arg2,(wxPoint const &)*arg3,(wxPoint const &)*arg4);
12811
12812 wxPyEndAllowThreads(__tstate);
12813 if (PyErr_Occurred()) SWIG_fail;
12814 }
12815 Py_INCREF(Py_None); resultobj = Py_None;
12816 return resultobj;
12817 fail:
12818 return NULL;
12819 }
12820
12821
12822 static PyObject *_wrap_DC_DrawCheckMark(PyObject *, PyObject *args, PyObject *kwargs) {
12823 PyObject *resultobj;
12824 wxDC *arg1 = (wxDC *) 0 ;
12825 int arg2 ;
12826 int arg3 ;
12827 int arg4 ;
12828 int arg5 ;
12829 PyObject * obj0 = 0 ;
12830 PyObject * obj1 = 0 ;
12831 PyObject * obj2 = 0 ;
12832 PyObject * obj3 = 0 ;
12833 PyObject * obj4 = 0 ;
12834 char *kwnames[] = {
12835 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
12836 };
12837
12838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawCheckMark",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12840 if (SWIG_arg_fail(1)) SWIG_fail;
12841 {
12842 arg2 = (int)(SWIG_As_int(obj1));
12843 if (SWIG_arg_fail(2)) SWIG_fail;
12844 }
12845 {
12846 arg3 = (int)(SWIG_As_int(obj2));
12847 if (SWIG_arg_fail(3)) SWIG_fail;
12848 }
12849 {
12850 arg4 = (int)(SWIG_As_int(obj3));
12851 if (SWIG_arg_fail(4)) SWIG_fail;
12852 }
12853 {
12854 arg5 = (int)(SWIG_As_int(obj4));
12855 if (SWIG_arg_fail(5)) SWIG_fail;
12856 }
12857 {
12858 PyThreadState* __tstate = wxPyBeginAllowThreads();
12859 (arg1)->DrawCheckMark(arg2,arg3,arg4,arg5);
12860
12861 wxPyEndAllowThreads(__tstate);
12862 if (PyErr_Occurred()) SWIG_fail;
12863 }
12864 Py_INCREF(Py_None); resultobj = Py_None;
12865 return resultobj;
12866 fail:
12867 return NULL;
12868 }
12869
12870
12871 static PyObject *_wrap_DC_DrawCheckMarkRect(PyObject *, PyObject *args, PyObject *kwargs) {
12872 PyObject *resultobj;
12873 wxDC *arg1 = (wxDC *) 0 ;
12874 wxRect *arg2 = 0 ;
12875 wxRect temp2 ;
12876 PyObject * obj0 = 0 ;
12877 PyObject * obj1 = 0 ;
12878 char *kwnames[] = {
12879 (char *) "self",(char *) "rect", NULL
12880 };
12881
12882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawCheckMarkRect",kwnames,&obj0,&obj1)) goto fail;
12883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12884 if (SWIG_arg_fail(1)) SWIG_fail;
12885 {
12886 arg2 = &temp2;
12887 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12888 }
12889 {
12890 PyThreadState* __tstate = wxPyBeginAllowThreads();
12891 (arg1)->DrawCheckMark((wxRect const &)*arg2);
12892
12893 wxPyEndAllowThreads(__tstate);
12894 if (PyErr_Occurred()) SWIG_fail;
12895 }
12896 Py_INCREF(Py_None); resultobj = Py_None;
12897 return resultobj;
12898 fail:
12899 return NULL;
12900 }
12901
12902
12903 static PyObject *_wrap_DC_DrawEllipticArc(PyObject *, PyObject *args, PyObject *kwargs) {
12904 PyObject *resultobj;
12905 wxDC *arg1 = (wxDC *) 0 ;
12906 int arg2 ;
12907 int arg3 ;
12908 int arg4 ;
12909 int arg5 ;
12910 double arg6 ;
12911 double arg7 ;
12912 PyObject * obj0 = 0 ;
12913 PyObject * obj1 = 0 ;
12914 PyObject * obj2 = 0 ;
12915 PyObject * obj3 = 0 ;
12916 PyObject * obj4 = 0 ;
12917 PyObject * obj5 = 0 ;
12918 PyObject * obj6 = 0 ;
12919 char *kwnames[] = {
12920 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h",(char *) "start",(char *) "end", NULL
12921 };
12922
12923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawEllipticArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) 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 arg2 = (int)(SWIG_As_int(obj1));
12928 if (SWIG_arg_fail(2)) SWIG_fail;
12929 }
12930 {
12931 arg3 = (int)(SWIG_As_int(obj2));
12932 if (SWIG_arg_fail(3)) SWIG_fail;
12933 }
12934 {
12935 arg4 = (int)(SWIG_As_int(obj3));
12936 if (SWIG_arg_fail(4)) SWIG_fail;
12937 }
12938 {
12939 arg5 = (int)(SWIG_As_int(obj4));
12940 if (SWIG_arg_fail(5)) SWIG_fail;
12941 }
12942 {
12943 arg6 = (double)(SWIG_As_double(obj5));
12944 if (SWIG_arg_fail(6)) SWIG_fail;
12945 }
12946 {
12947 arg7 = (double)(SWIG_As_double(obj6));
12948 if (SWIG_arg_fail(7)) SWIG_fail;
12949 }
12950 {
12951 PyThreadState* __tstate = wxPyBeginAllowThreads();
12952 (arg1)->DrawEllipticArc(arg2,arg3,arg4,arg5,arg6,arg7);
12953
12954 wxPyEndAllowThreads(__tstate);
12955 if (PyErr_Occurred()) SWIG_fail;
12956 }
12957 Py_INCREF(Py_None); resultobj = Py_None;
12958 return resultobj;
12959 fail:
12960 return NULL;
12961 }
12962
12963
12964 static PyObject *_wrap_DC_DrawEllipticArcPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
12965 PyObject *resultobj;
12966 wxDC *arg1 = (wxDC *) 0 ;
12967 wxPoint *arg2 = 0 ;
12968 wxSize *arg3 = 0 ;
12969 double arg4 ;
12970 double arg5 ;
12971 wxPoint temp2 ;
12972 wxSize temp3 ;
12973 PyObject * obj0 = 0 ;
12974 PyObject * obj1 = 0 ;
12975 PyObject * obj2 = 0 ;
12976 PyObject * obj3 = 0 ;
12977 PyObject * obj4 = 0 ;
12978 char *kwnames[] = {
12979 (char *) "self",(char *) "pt",(char *) "sz",(char *) "start",(char *) "end", NULL
12980 };
12981
12982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipticArcPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12984 if (SWIG_arg_fail(1)) SWIG_fail;
12985 {
12986 arg2 = &temp2;
12987 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12988 }
12989 {
12990 arg3 = &temp3;
12991 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
12992 }
12993 {
12994 arg4 = (double)(SWIG_As_double(obj3));
12995 if (SWIG_arg_fail(4)) SWIG_fail;
12996 }
12997 {
12998 arg5 = (double)(SWIG_As_double(obj4));
12999 if (SWIG_arg_fail(5)) SWIG_fail;
13000 }
13001 {
13002 PyThreadState* __tstate = wxPyBeginAllowThreads();
13003 (arg1)->DrawEllipticArc((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,arg5);
13004
13005 wxPyEndAllowThreads(__tstate);
13006 if (PyErr_Occurred()) SWIG_fail;
13007 }
13008 Py_INCREF(Py_None); resultobj = Py_None;
13009 return resultobj;
13010 fail:
13011 return NULL;
13012 }
13013
13014
13015 static PyObject *_wrap_DC_DrawPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13016 PyObject *resultobj;
13017 wxDC *arg1 = (wxDC *) 0 ;
13018 int arg2 ;
13019 int arg3 ;
13020 PyObject * obj0 = 0 ;
13021 PyObject * obj1 = 0 ;
13022 PyObject * obj2 = 0 ;
13023 char *kwnames[] = {
13024 (char *) "self",(char *) "x",(char *) "y", NULL
13025 };
13026
13027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13029 if (SWIG_arg_fail(1)) SWIG_fail;
13030 {
13031 arg2 = (int)(SWIG_As_int(obj1));
13032 if (SWIG_arg_fail(2)) SWIG_fail;
13033 }
13034 {
13035 arg3 = (int)(SWIG_As_int(obj2));
13036 if (SWIG_arg_fail(3)) SWIG_fail;
13037 }
13038 {
13039 PyThreadState* __tstate = wxPyBeginAllowThreads();
13040 (arg1)->DrawPoint(arg2,arg3);
13041
13042 wxPyEndAllowThreads(__tstate);
13043 if (PyErr_Occurred()) SWIG_fail;
13044 }
13045 Py_INCREF(Py_None); resultobj = Py_None;
13046 return resultobj;
13047 fail:
13048 return NULL;
13049 }
13050
13051
13052 static PyObject *_wrap_DC_DrawPointPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13053 PyObject *resultobj;
13054 wxDC *arg1 = (wxDC *) 0 ;
13055 wxPoint *arg2 = 0 ;
13056 wxPoint temp2 ;
13057 PyObject * obj0 = 0 ;
13058 PyObject * obj1 = 0 ;
13059 char *kwnames[] = {
13060 (char *) "self",(char *) "pt", NULL
13061 };
13062
13063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawPointPoint",kwnames,&obj0,&obj1)) goto fail;
13064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13065 if (SWIG_arg_fail(1)) SWIG_fail;
13066 {
13067 arg2 = &temp2;
13068 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13069 }
13070 {
13071 PyThreadState* __tstate = wxPyBeginAllowThreads();
13072 (arg1)->DrawPoint((wxPoint const &)*arg2);
13073
13074 wxPyEndAllowThreads(__tstate);
13075 if (PyErr_Occurred()) SWIG_fail;
13076 }
13077 Py_INCREF(Py_None); resultobj = Py_None;
13078 return resultobj;
13079 fail:
13080 return NULL;
13081 }
13082
13083
13084 static PyObject *_wrap_DC_DrawRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13085 PyObject *resultobj;
13086 wxDC *arg1 = (wxDC *) 0 ;
13087 int arg2 ;
13088 int arg3 ;
13089 int arg4 ;
13090 int arg5 ;
13091 PyObject * obj0 = 0 ;
13092 PyObject * obj1 = 0 ;
13093 PyObject * obj2 = 0 ;
13094 PyObject * obj3 = 0 ;
13095 PyObject * obj4 = 0 ;
13096 char *kwnames[] = {
13097 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13098 };
13099
13100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13102 if (SWIG_arg_fail(1)) SWIG_fail;
13103 {
13104 arg2 = (int)(SWIG_As_int(obj1));
13105 if (SWIG_arg_fail(2)) SWIG_fail;
13106 }
13107 {
13108 arg3 = (int)(SWIG_As_int(obj2));
13109 if (SWIG_arg_fail(3)) SWIG_fail;
13110 }
13111 {
13112 arg4 = (int)(SWIG_As_int(obj3));
13113 if (SWIG_arg_fail(4)) SWIG_fail;
13114 }
13115 {
13116 arg5 = (int)(SWIG_As_int(obj4));
13117 if (SWIG_arg_fail(5)) SWIG_fail;
13118 }
13119 {
13120 PyThreadState* __tstate = wxPyBeginAllowThreads();
13121 (arg1)->DrawRectangle(arg2,arg3,arg4,arg5);
13122
13123 wxPyEndAllowThreads(__tstate);
13124 if (PyErr_Occurred()) SWIG_fail;
13125 }
13126 Py_INCREF(Py_None); resultobj = Py_None;
13127 return resultobj;
13128 fail:
13129 return NULL;
13130 }
13131
13132
13133 static PyObject *_wrap_DC_DrawRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13134 PyObject *resultobj;
13135 wxDC *arg1 = (wxDC *) 0 ;
13136 wxRect *arg2 = 0 ;
13137 wxRect temp2 ;
13138 PyObject * obj0 = 0 ;
13139 PyObject * obj1 = 0 ;
13140 char *kwnames[] = {
13141 (char *) "self",(char *) "rect", NULL
13142 };
13143
13144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawRectangleRect",kwnames,&obj0,&obj1)) goto fail;
13145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13146 if (SWIG_arg_fail(1)) SWIG_fail;
13147 {
13148 arg2 = &temp2;
13149 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13150 }
13151 {
13152 PyThreadState* __tstate = wxPyBeginAllowThreads();
13153 (arg1)->DrawRectangle((wxRect const &)*arg2);
13154
13155 wxPyEndAllowThreads(__tstate);
13156 if (PyErr_Occurred()) SWIG_fail;
13157 }
13158 Py_INCREF(Py_None); resultobj = Py_None;
13159 return resultobj;
13160 fail:
13161 return NULL;
13162 }
13163
13164
13165 static PyObject *_wrap_DC_DrawRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13166 PyObject *resultobj;
13167 wxDC *arg1 = (wxDC *) 0 ;
13168 wxPoint *arg2 = 0 ;
13169 wxSize *arg3 = 0 ;
13170 wxPoint temp2 ;
13171 wxSize temp3 ;
13172 PyObject * obj0 = 0 ;
13173 PyObject * obj1 = 0 ;
13174 PyObject * obj2 = 0 ;
13175 char *kwnames[] = {
13176 (char *) "self",(char *) "pt",(char *) "sz", NULL
13177 };
13178
13179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRectanglePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13181 if (SWIG_arg_fail(1)) SWIG_fail;
13182 {
13183 arg2 = &temp2;
13184 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13185 }
13186 {
13187 arg3 = &temp3;
13188 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13189 }
13190 {
13191 PyThreadState* __tstate = wxPyBeginAllowThreads();
13192 (arg1)->DrawRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3);
13193
13194 wxPyEndAllowThreads(__tstate);
13195 if (PyErr_Occurred()) SWIG_fail;
13196 }
13197 Py_INCREF(Py_None); resultobj = Py_None;
13198 return resultobj;
13199 fail:
13200 return NULL;
13201 }
13202
13203
13204 static PyObject *_wrap_DC_DrawRoundedRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13205 PyObject *resultobj;
13206 wxDC *arg1 = (wxDC *) 0 ;
13207 int arg2 ;
13208 int arg3 ;
13209 int arg4 ;
13210 int arg5 ;
13211 double arg6 ;
13212 PyObject * obj0 = 0 ;
13213 PyObject * obj1 = 0 ;
13214 PyObject * obj2 = 0 ;
13215 PyObject * obj3 = 0 ;
13216 PyObject * obj4 = 0 ;
13217 PyObject * obj5 = 0 ;
13218 char *kwnames[] = {
13219 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "radius", NULL
13220 };
13221
13222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:DC_DrawRoundedRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
13223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13224 if (SWIG_arg_fail(1)) SWIG_fail;
13225 {
13226 arg2 = (int)(SWIG_As_int(obj1));
13227 if (SWIG_arg_fail(2)) SWIG_fail;
13228 }
13229 {
13230 arg3 = (int)(SWIG_As_int(obj2));
13231 if (SWIG_arg_fail(3)) SWIG_fail;
13232 }
13233 {
13234 arg4 = (int)(SWIG_As_int(obj3));
13235 if (SWIG_arg_fail(4)) SWIG_fail;
13236 }
13237 {
13238 arg5 = (int)(SWIG_As_int(obj4));
13239 if (SWIG_arg_fail(5)) SWIG_fail;
13240 }
13241 {
13242 arg6 = (double)(SWIG_As_double(obj5));
13243 if (SWIG_arg_fail(6)) SWIG_fail;
13244 }
13245 {
13246 PyThreadState* __tstate = wxPyBeginAllowThreads();
13247 (arg1)->DrawRoundedRectangle(arg2,arg3,arg4,arg5,arg6);
13248
13249 wxPyEndAllowThreads(__tstate);
13250 if (PyErr_Occurred()) SWIG_fail;
13251 }
13252 Py_INCREF(Py_None); resultobj = Py_None;
13253 return resultobj;
13254 fail:
13255 return NULL;
13256 }
13257
13258
13259 static PyObject *_wrap_DC_DrawRoundedRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13260 PyObject *resultobj;
13261 wxDC *arg1 = (wxDC *) 0 ;
13262 wxRect *arg2 = 0 ;
13263 double arg3 ;
13264 wxRect temp2 ;
13265 PyObject * obj0 = 0 ;
13266 PyObject * obj1 = 0 ;
13267 PyObject * obj2 = 0 ;
13268 char *kwnames[] = {
13269 (char *) "self",(char *) "r",(char *) "radius", NULL
13270 };
13271
13272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRoundedRectangleRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
13273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13274 if (SWIG_arg_fail(1)) SWIG_fail;
13275 {
13276 arg2 = &temp2;
13277 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13278 }
13279 {
13280 arg3 = (double)(SWIG_As_double(obj2));
13281 if (SWIG_arg_fail(3)) SWIG_fail;
13282 }
13283 {
13284 PyThreadState* __tstate = wxPyBeginAllowThreads();
13285 (arg1)->DrawRoundedRectangle((wxRect const &)*arg2,arg3);
13286
13287 wxPyEndAllowThreads(__tstate);
13288 if (PyErr_Occurred()) SWIG_fail;
13289 }
13290 Py_INCREF(Py_None); resultobj = Py_None;
13291 return resultobj;
13292 fail:
13293 return NULL;
13294 }
13295
13296
13297 static PyObject *_wrap_DC_DrawRoundedRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13298 PyObject *resultobj;
13299 wxDC *arg1 = (wxDC *) 0 ;
13300 wxPoint *arg2 = 0 ;
13301 wxSize *arg3 = 0 ;
13302 double arg4 ;
13303 wxPoint temp2 ;
13304 wxSize temp3 ;
13305 PyObject * obj0 = 0 ;
13306 PyObject * obj1 = 0 ;
13307 PyObject * obj2 = 0 ;
13308 PyObject * obj3 = 0 ;
13309 char *kwnames[] = {
13310 (char *) "self",(char *) "pt",(char *) "sz",(char *) "radius", NULL
13311 };
13312
13313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRoundedRectanglePointSize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13315 if (SWIG_arg_fail(1)) SWIG_fail;
13316 {
13317 arg2 = &temp2;
13318 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13319 }
13320 {
13321 arg3 = &temp3;
13322 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13323 }
13324 {
13325 arg4 = (double)(SWIG_As_double(obj3));
13326 if (SWIG_arg_fail(4)) SWIG_fail;
13327 }
13328 {
13329 PyThreadState* __tstate = wxPyBeginAllowThreads();
13330 (arg1)->DrawRoundedRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4);
13331
13332 wxPyEndAllowThreads(__tstate);
13333 if (PyErr_Occurred()) SWIG_fail;
13334 }
13335 Py_INCREF(Py_None); resultobj = Py_None;
13336 return resultobj;
13337 fail:
13338 return NULL;
13339 }
13340
13341
13342 static PyObject *_wrap_DC_DrawCircle(PyObject *, PyObject *args, PyObject *kwargs) {
13343 PyObject *resultobj;
13344 wxDC *arg1 = (wxDC *) 0 ;
13345 int arg2 ;
13346 int arg3 ;
13347 int arg4 ;
13348 PyObject * obj0 = 0 ;
13349 PyObject * obj1 = 0 ;
13350 PyObject * obj2 = 0 ;
13351 PyObject * obj3 = 0 ;
13352 char *kwnames[] = {
13353 (char *) "self",(char *) "x",(char *) "y",(char *) "radius", NULL
13354 };
13355
13356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawCircle",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13358 if (SWIG_arg_fail(1)) SWIG_fail;
13359 {
13360 arg2 = (int)(SWIG_As_int(obj1));
13361 if (SWIG_arg_fail(2)) SWIG_fail;
13362 }
13363 {
13364 arg3 = (int)(SWIG_As_int(obj2));
13365 if (SWIG_arg_fail(3)) SWIG_fail;
13366 }
13367 {
13368 arg4 = (int)(SWIG_As_int(obj3));
13369 if (SWIG_arg_fail(4)) SWIG_fail;
13370 }
13371 {
13372 PyThreadState* __tstate = wxPyBeginAllowThreads();
13373 (arg1)->DrawCircle(arg2,arg3,arg4);
13374
13375 wxPyEndAllowThreads(__tstate);
13376 if (PyErr_Occurred()) SWIG_fail;
13377 }
13378 Py_INCREF(Py_None); resultobj = Py_None;
13379 return resultobj;
13380 fail:
13381 return NULL;
13382 }
13383
13384
13385 static PyObject *_wrap_DC_DrawCirclePoint(PyObject *, PyObject *args, PyObject *kwargs) {
13386 PyObject *resultobj;
13387 wxDC *arg1 = (wxDC *) 0 ;
13388 wxPoint *arg2 = 0 ;
13389 int arg3 ;
13390 wxPoint temp2 ;
13391 PyObject * obj0 = 0 ;
13392 PyObject * obj1 = 0 ;
13393 PyObject * obj2 = 0 ;
13394 char *kwnames[] = {
13395 (char *) "self",(char *) "pt",(char *) "radius", NULL
13396 };
13397
13398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawCirclePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13400 if (SWIG_arg_fail(1)) SWIG_fail;
13401 {
13402 arg2 = &temp2;
13403 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13404 }
13405 {
13406 arg3 = (int)(SWIG_As_int(obj2));
13407 if (SWIG_arg_fail(3)) SWIG_fail;
13408 }
13409 {
13410 PyThreadState* __tstate = wxPyBeginAllowThreads();
13411 (arg1)->DrawCircle((wxPoint const &)*arg2,arg3);
13412
13413 wxPyEndAllowThreads(__tstate);
13414 if (PyErr_Occurred()) SWIG_fail;
13415 }
13416 Py_INCREF(Py_None); resultobj = Py_None;
13417 return resultobj;
13418 fail:
13419 return NULL;
13420 }
13421
13422
13423 static PyObject *_wrap_DC_DrawEllipse(PyObject *, PyObject *args, PyObject *kwargs) {
13424 PyObject *resultobj;
13425 wxDC *arg1 = (wxDC *) 0 ;
13426 int arg2 ;
13427 int arg3 ;
13428 int arg4 ;
13429 int arg5 ;
13430 PyObject * obj0 = 0 ;
13431 PyObject * obj1 = 0 ;
13432 PyObject * obj2 = 0 ;
13433 PyObject * obj3 = 0 ;
13434 PyObject * obj4 = 0 ;
13435 char *kwnames[] = {
13436 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13437 };
13438
13439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipse",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13441 if (SWIG_arg_fail(1)) SWIG_fail;
13442 {
13443 arg2 = (int)(SWIG_As_int(obj1));
13444 if (SWIG_arg_fail(2)) SWIG_fail;
13445 }
13446 {
13447 arg3 = (int)(SWIG_As_int(obj2));
13448 if (SWIG_arg_fail(3)) SWIG_fail;
13449 }
13450 {
13451 arg4 = (int)(SWIG_As_int(obj3));
13452 if (SWIG_arg_fail(4)) SWIG_fail;
13453 }
13454 {
13455 arg5 = (int)(SWIG_As_int(obj4));
13456 if (SWIG_arg_fail(5)) SWIG_fail;
13457 }
13458 {
13459 PyThreadState* __tstate = wxPyBeginAllowThreads();
13460 (arg1)->DrawEllipse(arg2,arg3,arg4,arg5);
13461
13462 wxPyEndAllowThreads(__tstate);
13463 if (PyErr_Occurred()) SWIG_fail;
13464 }
13465 Py_INCREF(Py_None); resultobj = Py_None;
13466 return resultobj;
13467 fail:
13468 return NULL;
13469 }
13470
13471
13472 static PyObject *_wrap_DC_DrawEllipseRect(PyObject *, PyObject *args, PyObject *kwargs) {
13473 PyObject *resultobj;
13474 wxDC *arg1 = (wxDC *) 0 ;
13475 wxRect *arg2 = 0 ;
13476 wxRect temp2 ;
13477 PyObject * obj0 = 0 ;
13478 PyObject * obj1 = 0 ;
13479 char *kwnames[] = {
13480 (char *) "self",(char *) "rect", NULL
13481 };
13482
13483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawEllipseRect",kwnames,&obj0,&obj1)) goto fail;
13484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13485 if (SWIG_arg_fail(1)) SWIG_fail;
13486 {
13487 arg2 = &temp2;
13488 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13489 }
13490 {
13491 PyThreadState* __tstate = wxPyBeginAllowThreads();
13492 (arg1)->DrawEllipse((wxRect const &)*arg2);
13493
13494 wxPyEndAllowThreads(__tstate);
13495 if (PyErr_Occurred()) SWIG_fail;
13496 }
13497 Py_INCREF(Py_None); resultobj = Py_None;
13498 return resultobj;
13499 fail:
13500 return NULL;
13501 }
13502
13503
13504 static PyObject *_wrap_DC_DrawEllipsePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13505 PyObject *resultobj;
13506 wxDC *arg1 = (wxDC *) 0 ;
13507 wxPoint *arg2 = 0 ;
13508 wxSize *arg3 = 0 ;
13509 wxPoint temp2 ;
13510 wxSize temp3 ;
13511 PyObject * obj0 = 0 ;
13512 PyObject * obj1 = 0 ;
13513 PyObject * obj2 = 0 ;
13514 char *kwnames[] = {
13515 (char *) "self",(char *) "pt",(char *) "sz", NULL
13516 };
13517
13518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawEllipsePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13520 if (SWIG_arg_fail(1)) SWIG_fail;
13521 {
13522 arg2 = &temp2;
13523 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13524 }
13525 {
13526 arg3 = &temp3;
13527 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13528 }
13529 {
13530 PyThreadState* __tstate = wxPyBeginAllowThreads();
13531 (arg1)->DrawEllipse((wxPoint const &)*arg2,(wxSize const &)*arg3);
13532
13533 wxPyEndAllowThreads(__tstate);
13534 if (PyErr_Occurred()) SWIG_fail;
13535 }
13536 Py_INCREF(Py_None); resultobj = Py_None;
13537 return resultobj;
13538 fail:
13539 return NULL;
13540 }
13541
13542
13543 static PyObject *_wrap_DC_DrawIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13544 PyObject *resultobj;
13545 wxDC *arg1 = (wxDC *) 0 ;
13546 wxIcon *arg2 = 0 ;
13547 int arg3 ;
13548 int arg4 ;
13549 PyObject * obj0 = 0 ;
13550 PyObject * obj1 = 0 ;
13551 PyObject * obj2 = 0 ;
13552 PyObject * obj3 = 0 ;
13553 char *kwnames[] = {
13554 (char *) "self",(char *) "icon",(char *) "x",(char *) "y", NULL
13555 };
13556
13557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13559 if (SWIG_arg_fail(1)) SWIG_fail;
13560 {
13561 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
13562 if (SWIG_arg_fail(2)) SWIG_fail;
13563 if (arg2 == NULL) {
13564 SWIG_null_ref("wxIcon");
13565 }
13566 if (SWIG_arg_fail(2)) SWIG_fail;
13567 }
13568 {
13569 arg3 = (int)(SWIG_As_int(obj2));
13570 if (SWIG_arg_fail(3)) SWIG_fail;
13571 }
13572 {
13573 arg4 = (int)(SWIG_As_int(obj3));
13574 if (SWIG_arg_fail(4)) SWIG_fail;
13575 }
13576 {
13577 PyThreadState* __tstate = wxPyBeginAllowThreads();
13578 (arg1)->DrawIcon((wxIcon const &)*arg2,arg3,arg4);
13579
13580 wxPyEndAllowThreads(__tstate);
13581 if (PyErr_Occurred()) SWIG_fail;
13582 }
13583 Py_INCREF(Py_None); resultobj = Py_None;
13584 return resultobj;
13585 fail:
13586 return NULL;
13587 }
13588
13589
13590 static PyObject *_wrap_DC_DrawIconPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13591 PyObject *resultobj;
13592 wxDC *arg1 = (wxDC *) 0 ;
13593 wxIcon *arg2 = 0 ;
13594 wxPoint *arg3 = 0 ;
13595 wxPoint temp3 ;
13596 PyObject * obj0 = 0 ;
13597 PyObject * obj1 = 0 ;
13598 PyObject * obj2 = 0 ;
13599 char *kwnames[] = {
13600 (char *) "self",(char *) "icon",(char *) "pt", NULL
13601 };
13602
13603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawIconPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13605 if (SWIG_arg_fail(1)) SWIG_fail;
13606 {
13607 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
13608 if (SWIG_arg_fail(2)) SWIG_fail;
13609 if (arg2 == NULL) {
13610 SWIG_null_ref("wxIcon");
13611 }
13612 if (SWIG_arg_fail(2)) SWIG_fail;
13613 }
13614 {
13615 arg3 = &temp3;
13616 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13617 }
13618 {
13619 PyThreadState* __tstate = wxPyBeginAllowThreads();
13620 (arg1)->DrawIcon((wxIcon const &)*arg2,(wxPoint const &)*arg3);
13621
13622 wxPyEndAllowThreads(__tstate);
13623 if (PyErr_Occurred()) SWIG_fail;
13624 }
13625 Py_INCREF(Py_None); resultobj = Py_None;
13626 return resultobj;
13627 fail:
13628 return NULL;
13629 }
13630
13631
13632 static PyObject *_wrap_DC_DrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13633 PyObject *resultobj;
13634 wxDC *arg1 = (wxDC *) 0 ;
13635 wxBitmap *arg2 = 0 ;
13636 int arg3 ;
13637 int arg4 ;
13638 bool arg5 = (bool) false ;
13639 PyObject * obj0 = 0 ;
13640 PyObject * obj1 = 0 ;
13641 PyObject * obj2 = 0 ;
13642 PyObject * obj3 = 0 ;
13643 PyObject * obj4 = 0 ;
13644 char *kwnames[] = {
13645 (char *) "self",(char *) "bmp",(char *) "x",(char *) "y",(char *) "useMask", NULL
13646 };
13647
13648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_DrawBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13650 if (SWIG_arg_fail(1)) SWIG_fail;
13651 {
13652 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
13653 if (SWIG_arg_fail(2)) SWIG_fail;
13654 if (arg2 == NULL) {
13655 SWIG_null_ref("wxBitmap");
13656 }
13657 if (SWIG_arg_fail(2)) SWIG_fail;
13658 }
13659 {
13660 arg3 = (int)(SWIG_As_int(obj2));
13661 if (SWIG_arg_fail(3)) SWIG_fail;
13662 }
13663 {
13664 arg4 = (int)(SWIG_As_int(obj3));
13665 if (SWIG_arg_fail(4)) SWIG_fail;
13666 }
13667 if (obj4) {
13668 {
13669 arg5 = (bool)(SWIG_As_bool(obj4));
13670 if (SWIG_arg_fail(5)) SWIG_fail;
13671 }
13672 }
13673 {
13674 PyThreadState* __tstate = wxPyBeginAllowThreads();
13675 (arg1)->DrawBitmap((wxBitmap const &)*arg2,arg3,arg4,arg5);
13676
13677 wxPyEndAllowThreads(__tstate);
13678 if (PyErr_Occurred()) SWIG_fail;
13679 }
13680 Py_INCREF(Py_None); resultobj = Py_None;
13681 return resultobj;
13682 fail:
13683 return NULL;
13684 }
13685
13686
13687 static PyObject *_wrap_DC_DrawBitmapPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13688 PyObject *resultobj;
13689 wxDC *arg1 = (wxDC *) 0 ;
13690 wxBitmap *arg2 = 0 ;
13691 wxPoint *arg3 = 0 ;
13692 bool arg4 = (bool) false ;
13693 wxPoint temp3 ;
13694 PyObject * obj0 = 0 ;
13695 PyObject * obj1 = 0 ;
13696 PyObject * obj2 = 0 ;
13697 PyObject * obj3 = 0 ;
13698 char *kwnames[] = {
13699 (char *) "self",(char *) "bmp",(char *) "pt",(char *) "useMask", NULL
13700 };
13701
13702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_DrawBitmapPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13704 if (SWIG_arg_fail(1)) SWIG_fail;
13705 {
13706 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
13707 if (SWIG_arg_fail(2)) SWIG_fail;
13708 if (arg2 == NULL) {
13709 SWIG_null_ref("wxBitmap");
13710 }
13711 if (SWIG_arg_fail(2)) SWIG_fail;
13712 }
13713 {
13714 arg3 = &temp3;
13715 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13716 }
13717 if (obj3) {
13718 {
13719 arg4 = (bool)(SWIG_As_bool(obj3));
13720 if (SWIG_arg_fail(4)) SWIG_fail;
13721 }
13722 }
13723 {
13724 PyThreadState* __tstate = wxPyBeginAllowThreads();
13725 (arg1)->DrawBitmap((wxBitmap const &)*arg2,(wxPoint const &)*arg3,arg4);
13726
13727 wxPyEndAllowThreads(__tstate);
13728 if (PyErr_Occurred()) SWIG_fail;
13729 }
13730 Py_INCREF(Py_None); resultobj = Py_None;
13731 return resultobj;
13732 fail:
13733 return NULL;
13734 }
13735
13736
13737 static PyObject *_wrap_DC_DrawText(PyObject *, PyObject *args, PyObject *kwargs) {
13738 PyObject *resultobj;
13739 wxDC *arg1 = (wxDC *) 0 ;
13740 wxString *arg2 = 0 ;
13741 int arg3 ;
13742 int arg4 ;
13743 bool temp2 = false ;
13744 PyObject * obj0 = 0 ;
13745 PyObject * obj1 = 0 ;
13746 PyObject * obj2 = 0 ;
13747 PyObject * obj3 = 0 ;
13748 char *kwnames[] = {
13749 (char *) "self",(char *) "text",(char *) "x",(char *) "y", NULL
13750 };
13751
13752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawText",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13754 if (SWIG_arg_fail(1)) SWIG_fail;
13755 {
13756 arg2 = wxString_in_helper(obj1);
13757 if (arg2 == NULL) SWIG_fail;
13758 temp2 = true;
13759 }
13760 {
13761 arg3 = (int)(SWIG_As_int(obj2));
13762 if (SWIG_arg_fail(3)) SWIG_fail;
13763 }
13764 {
13765 arg4 = (int)(SWIG_As_int(obj3));
13766 if (SWIG_arg_fail(4)) SWIG_fail;
13767 }
13768 {
13769 PyThreadState* __tstate = wxPyBeginAllowThreads();
13770 (arg1)->DrawText((wxString const &)*arg2,arg3,arg4);
13771
13772 wxPyEndAllowThreads(__tstate);
13773 if (PyErr_Occurred()) SWIG_fail;
13774 }
13775 Py_INCREF(Py_None); resultobj = Py_None;
13776 {
13777 if (temp2)
13778 delete arg2;
13779 }
13780 return resultobj;
13781 fail:
13782 {
13783 if (temp2)
13784 delete arg2;
13785 }
13786 return NULL;
13787 }
13788
13789
13790 static PyObject *_wrap_DC_DrawTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13791 PyObject *resultobj;
13792 wxDC *arg1 = (wxDC *) 0 ;
13793 wxString *arg2 = 0 ;
13794 wxPoint *arg3 = 0 ;
13795 bool temp2 = false ;
13796 wxPoint temp3 ;
13797 PyObject * obj0 = 0 ;
13798 PyObject * obj1 = 0 ;
13799 PyObject * obj2 = 0 ;
13800 char *kwnames[] = {
13801 (char *) "self",(char *) "text",(char *) "pt", NULL
13802 };
13803
13804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawTextPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13806 if (SWIG_arg_fail(1)) SWIG_fail;
13807 {
13808 arg2 = wxString_in_helper(obj1);
13809 if (arg2 == NULL) SWIG_fail;
13810 temp2 = true;
13811 }
13812 {
13813 arg3 = &temp3;
13814 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13815 }
13816 {
13817 PyThreadState* __tstate = wxPyBeginAllowThreads();
13818 (arg1)->DrawText((wxString const &)*arg2,(wxPoint const &)*arg3);
13819
13820 wxPyEndAllowThreads(__tstate);
13821 if (PyErr_Occurred()) SWIG_fail;
13822 }
13823 Py_INCREF(Py_None); resultobj = Py_None;
13824 {
13825 if (temp2)
13826 delete arg2;
13827 }
13828 return resultobj;
13829 fail:
13830 {
13831 if (temp2)
13832 delete arg2;
13833 }
13834 return NULL;
13835 }
13836
13837
13838 static PyObject *_wrap_DC_DrawRotatedText(PyObject *, PyObject *args, PyObject *kwargs) {
13839 PyObject *resultobj;
13840 wxDC *arg1 = (wxDC *) 0 ;
13841 wxString *arg2 = 0 ;
13842 int arg3 ;
13843 int arg4 ;
13844 double arg5 ;
13845 bool temp2 = false ;
13846 PyObject * obj0 = 0 ;
13847 PyObject * obj1 = 0 ;
13848 PyObject * obj2 = 0 ;
13849 PyObject * obj3 = 0 ;
13850 PyObject * obj4 = 0 ;
13851 char *kwnames[] = {
13852 (char *) "self",(char *) "text",(char *) "x",(char *) "y",(char *) "angle", NULL
13853 };
13854
13855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRotatedText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13857 if (SWIG_arg_fail(1)) SWIG_fail;
13858 {
13859 arg2 = wxString_in_helper(obj1);
13860 if (arg2 == NULL) SWIG_fail;
13861 temp2 = true;
13862 }
13863 {
13864 arg3 = (int)(SWIG_As_int(obj2));
13865 if (SWIG_arg_fail(3)) SWIG_fail;
13866 }
13867 {
13868 arg4 = (int)(SWIG_As_int(obj3));
13869 if (SWIG_arg_fail(4)) SWIG_fail;
13870 }
13871 {
13872 arg5 = (double)(SWIG_As_double(obj4));
13873 if (SWIG_arg_fail(5)) SWIG_fail;
13874 }
13875 {
13876 PyThreadState* __tstate = wxPyBeginAllowThreads();
13877 (arg1)->DrawRotatedText((wxString const &)*arg2,arg3,arg4,arg5);
13878
13879 wxPyEndAllowThreads(__tstate);
13880 if (PyErr_Occurred()) SWIG_fail;
13881 }
13882 Py_INCREF(Py_None); resultobj = Py_None;
13883 {
13884 if (temp2)
13885 delete arg2;
13886 }
13887 return resultobj;
13888 fail:
13889 {
13890 if (temp2)
13891 delete arg2;
13892 }
13893 return NULL;
13894 }
13895
13896
13897 static PyObject *_wrap_DC_DrawRotatedTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13898 PyObject *resultobj;
13899 wxDC *arg1 = (wxDC *) 0 ;
13900 wxString *arg2 = 0 ;
13901 wxPoint *arg3 = 0 ;
13902 double arg4 ;
13903 bool temp2 = false ;
13904 wxPoint temp3 ;
13905 PyObject * obj0 = 0 ;
13906 PyObject * obj1 = 0 ;
13907 PyObject * obj2 = 0 ;
13908 PyObject * obj3 = 0 ;
13909 char *kwnames[] = {
13910 (char *) "self",(char *) "text",(char *) "pt",(char *) "angle", NULL
13911 };
13912
13913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRotatedTextPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13915 if (SWIG_arg_fail(1)) SWIG_fail;
13916 {
13917 arg2 = wxString_in_helper(obj1);
13918 if (arg2 == NULL) SWIG_fail;
13919 temp2 = true;
13920 }
13921 {
13922 arg3 = &temp3;
13923 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13924 }
13925 {
13926 arg4 = (double)(SWIG_As_double(obj3));
13927 if (SWIG_arg_fail(4)) SWIG_fail;
13928 }
13929 {
13930 PyThreadState* __tstate = wxPyBeginAllowThreads();
13931 (arg1)->DrawRotatedText((wxString const &)*arg2,(wxPoint const &)*arg3,arg4);
13932
13933 wxPyEndAllowThreads(__tstate);
13934 if (PyErr_Occurred()) SWIG_fail;
13935 }
13936 Py_INCREF(Py_None); resultobj = Py_None;
13937 {
13938 if (temp2)
13939 delete arg2;
13940 }
13941 return resultobj;
13942 fail:
13943 {
13944 if (temp2)
13945 delete arg2;
13946 }
13947 return NULL;
13948 }
13949
13950
13951 static PyObject *_wrap_DC_Blit(PyObject *, PyObject *args, PyObject *kwargs) {
13952 PyObject *resultobj;
13953 wxDC *arg1 = (wxDC *) 0 ;
13954 int arg2 ;
13955 int arg3 ;
13956 int arg4 ;
13957 int arg5 ;
13958 wxDC *arg6 = (wxDC *) 0 ;
13959 int arg7 ;
13960 int arg8 ;
13961 int arg9 = (int) wxCOPY ;
13962 bool arg10 = (bool) false ;
13963 int arg11 = (int) -1 ;
13964 int arg12 = (int) -1 ;
13965 bool result;
13966 PyObject * obj0 = 0 ;
13967 PyObject * obj1 = 0 ;
13968 PyObject * obj2 = 0 ;
13969 PyObject * obj3 = 0 ;
13970 PyObject * obj4 = 0 ;
13971 PyObject * obj5 = 0 ;
13972 PyObject * obj6 = 0 ;
13973 PyObject * obj7 = 0 ;
13974 PyObject * obj8 = 0 ;
13975 PyObject * obj9 = 0 ;
13976 PyObject * obj10 = 0 ;
13977 PyObject * obj11 = 0 ;
13978 char *kwnames[] = {
13979 (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
13980 };
13981
13982 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;
13983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13984 if (SWIG_arg_fail(1)) SWIG_fail;
13985 {
13986 arg2 = (int)(SWIG_As_int(obj1));
13987 if (SWIG_arg_fail(2)) SWIG_fail;
13988 }
13989 {
13990 arg3 = (int)(SWIG_As_int(obj2));
13991 if (SWIG_arg_fail(3)) SWIG_fail;
13992 }
13993 {
13994 arg4 = (int)(SWIG_As_int(obj3));
13995 if (SWIG_arg_fail(4)) SWIG_fail;
13996 }
13997 {
13998 arg5 = (int)(SWIG_As_int(obj4));
13999 if (SWIG_arg_fail(5)) SWIG_fail;
14000 }
14001 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14002 if (SWIG_arg_fail(6)) SWIG_fail;
14003 {
14004 arg7 = (int)(SWIG_As_int(obj6));
14005 if (SWIG_arg_fail(7)) SWIG_fail;
14006 }
14007 {
14008 arg8 = (int)(SWIG_As_int(obj7));
14009 if (SWIG_arg_fail(8)) SWIG_fail;
14010 }
14011 if (obj8) {
14012 {
14013 arg9 = (int)(SWIG_As_int(obj8));
14014 if (SWIG_arg_fail(9)) SWIG_fail;
14015 }
14016 }
14017 if (obj9) {
14018 {
14019 arg10 = (bool)(SWIG_As_bool(obj9));
14020 if (SWIG_arg_fail(10)) SWIG_fail;
14021 }
14022 }
14023 if (obj10) {
14024 {
14025 arg11 = (int)(SWIG_As_int(obj10));
14026 if (SWIG_arg_fail(11)) SWIG_fail;
14027 }
14028 }
14029 if (obj11) {
14030 {
14031 arg12 = (int)(SWIG_As_int(obj11));
14032 if (SWIG_arg_fail(12)) SWIG_fail;
14033 }
14034 }
14035 {
14036 PyThreadState* __tstate = wxPyBeginAllowThreads();
14037 result = (bool)(arg1)->Blit(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
14038
14039 wxPyEndAllowThreads(__tstate);
14040 if (PyErr_Occurred()) SWIG_fail;
14041 }
14042 {
14043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14044 }
14045 return resultobj;
14046 fail:
14047 return NULL;
14048 }
14049
14050
14051 static PyObject *_wrap_DC_BlitPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14052 PyObject *resultobj;
14053 wxDC *arg1 = (wxDC *) 0 ;
14054 wxPoint *arg2 = 0 ;
14055 wxSize *arg3 = 0 ;
14056 wxDC *arg4 = (wxDC *) 0 ;
14057 wxPoint *arg5 = 0 ;
14058 int arg6 = (int) wxCOPY ;
14059 bool arg7 = (bool) false ;
14060 wxPoint const &arg8_defvalue = wxDefaultPosition ;
14061 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
14062 bool result;
14063 wxPoint temp2 ;
14064 wxSize temp3 ;
14065 wxPoint temp5 ;
14066 wxPoint temp8 ;
14067 PyObject * obj0 = 0 ;
14068 PyObject * obj1 = 0 ;
14069 PyObject * obj2 = 0 ;
14070 PyObject * obj3 = 0 ;
14071 PyObject * obj4 = 0 ;
14072 PyObject * obj5 = 0 ;
14073 PyObject * obj6 = 0 ;
14074 PyObject * obj7 = 0 ;
14075 char *kwnames[] = {
14076 (char *) "self",(char *) "destPt",(char *) "sz",(char *) "source",(char *) "srcPt",(char *) "rop",(char *) "useMask",(char *) "srcPtMask", NULL
14077 };
14078
14079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:DC_BlitPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
14080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14081 if (SWIG_arg_fail(1)) SWIG_fail;
14082 {
14083 arg2 = &temp2;
14084 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14085 }
14086 {
14087 arg3 = &temp3;
14088 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14089 }
14090 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14091 if (SWIG_arg_fail(4)) SWIG_fail;
14092 {
14093 arg5 = &temp5;
14094 if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
14095 }
14096 if (obj5) {
14097 {
14098 arg6 = (int)(SWIG_As_int(obj5));
14099 if (SWIG_arg_fail(6)) SWIG_fail;
14100 }
14101 }
14102 if (obj6) {
14103 {
14104 arg7 = (bool)(SWIG_As_bool(obj6));
14105 if (SWIG_arg_fail(7)) SWIG_fail;
14106 }
14107 }
14108 if (obj7) {
14109 {
14110 arg8 = &temp8;
14111 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
14112 }
14113 }
14114 {
14115 PyThreadState* __tstate = wxPyBeginAllowThreads();
14116 result = (bool)(arg1)->Blit((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,(wxPoint const &)*arg5,arg6,arg7,(wxPoint const &)*arg8);
14117
14118 wxPyEndAllowThreads(__tstate);
14119 if (PyErr_Occurred()) SWIG_fail;
14120 }
14121 {
14122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14123 }
14124 return resultobj;
14125 fail:
14126 return NULL;
14127 }
14128
14129
14130 static PyObject *_wrap_DC_SetClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14131 PyObject *resultobj;
14132 wxDC *arg1 = (wxDC *) 0 ;
14133 int arg2 ;
14134 int arg3 ;
14135 int arg4 ;
14136 int arg5 ;
14137 PyObject * obj0 = 0 ;
14138 PyObject * obj1 = 0 ;
14139 PyObject * obj2 = 0 ;
14140 PyObject * obj3 = 0 ;
14141 PyObject * obj4 = 0 ;
14142 char *kwnames[] = {
14143 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
14144 };
14145
14146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_SetClippingRegion",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14148 if (SWIG_arg_fail(1)) SWIG_fail;
14149 {
14150 arg2 = (int)(SWIG_As_int(obj1));
14151 if (SWIG_arg_fail(2)) SWIG_fail;
14152 }
14153 {
14154 arg3 = (int)(SWIG_As_int(obj2));
14155 if (SWIG_arg_fail(3)) SWIG_fail;
14156 }
14157 {
14158 arg4 = (int)(SWIG_As_int(obj3));
14159 if (SWIG_arg_fail(4)) SWIG_fail;
14160 }
14161 {
14162 arg5 = (int)(SWIG_As_int(obj4));
14163 if (SWIG_arg_fail(5)) SWIG_fail;
14164 }
14165 {
14166 PyThreadState* __tstate = wxPyBeginAllowThreads();
14167 (arg1)->SetClippingRegion(arg2,arg3,arg4,arg5);
14168
14169 wxPyEndAllowThreads(__tstate);
14170 if (PyErr_Occurred()) SWIG_fail;
14171 }
14172 Py_INCREF(Py_None); resultobj = Py_None;
14173 return resultobj;
14174 fail:
14175 return NULL;
14176 }
14177
14178
14179 static PyObject *_wrap_DC_SetClippingRegionPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14180 PyObject *resultobj;
14181 wxDC *arg1 = (wxDC *) 0 ;
14182 wxPoint *arg2 = 0 ;
14183 wxSize *arg3 = 0 ;
14184 wxPoint temp2 ;
14185 wxSize temp3 ;
14186 PyObject * obj0 = 0 ;
14187 PyObject * obj1 = 0 ;
14188 PyObject * obj2 = 0 ;
14189 char *kwnames[] = {
14190 (char *) "self",(char *) "pt",(char *) "sz", NULL
14191 };
14192
14193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetClippingRegionPointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14195 if (SWIG_arg_fail(1)) SWIG_fail;
14196 {
14197 arg2 = &temp2;
14198 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14199 }
14200 {
14201 arg3 = &temp3;
14202 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14203 }
14204 {
14205 PyThreadState* __tstate = wxPyBeginAllowThreads();
14206 (arg1)->SetClippingRegion((wxPoint const &)*arg2,(wxSize const &)*arg3);
14207
14208 wxPyEndAllowThreads(__tstate);
14209 if (PyErr_Occurred()) SWIG_fail;
14210 }
14211 Py_INCREF(Py_None); resultobj = Py_None;
14212 return resultobj;
14213 fail:
14214 return NULL;
14215 }
14216
14217
14218 static PyObject *_wrap_DC_SetClippingRegionAsRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14219 PyObject *resultobj;
14220 wxDC *arg1 = (wxDC *) 0 ;
14221 wxRegion *arg2 = 0 ;
14222 PyObject * obj0 = 0 ;
14223 PyObject * obj1 = 0 ;
14224 char *kwnames[] = {
14225 (char *) "self",(char *) "region", NULL
14226 };
14227
14228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRegionAsRegion",kwnames,&obj0,&obj1)) goto fail;
14229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14230 if (SWIG_arg_fail(1)) SWIG_fail;
14231 {
14232 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
14233 if (SWIG_arg_fail(2)) SWIG_fail;
14234 if (arg2 == NULL) {
14235 SWIG_null_ref("wxRegion");
14236 }
14237 if (SWIG_arg_fail(2)) SWIG_fail;
14238 }
14239 {
14240 PyThreadState* __tstate = wxPyBeginAllowThreads();
14241 (arg1)->SetClippingRegion((wxRegion const &)*arg2);
14242
14243 wxPyEndAllowThreads(__tstate);
14244 if (PyErr_Occurred()) SWIG_fail;
14245 }
14246 Py_INCREF(Py_None); resultobj = Py_None;
14247 return resultobj;
14248 fail:
14249 return NULL;
14250 }
14251
14252
14253 static PyObject *_wrap_DC_SetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
14254 PyObject *resultobj;
14255 wxDC *arg1 = (wxDC *) 0 ;
14256 wxRect *arg2 = 0 ;
14257 wxRect temp2 ;
14258 PyObject * obj0 = 0 ;
14259 PyObject * obj1 = 0 ;
14260 char *kwnames[] = {
14261 (char *) "self",(char *) "rect", NULL
14262 };
14263
14264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRect",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
14269 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14270 }
14271 {
14272 PyThreadState* __tstate = wxPyBeginAllowThreads();
14273 (arg1)->SetClippingRegion((wxRect const &)*arg2);
14274
14275 wxPyEndAllowThreads(__tstate);
14276 if (PyErr_Occurred()) SWIG_fail;
14277 }
14278 Py_INCREF(Py_None); resultobj = Py_None;
14279 return resultobj;
14280 fail:
14281 return NULL;
14282 }
14283
14284
14285 static PyObject *_wrap_DC_DrawLines(PyObject *, PyObject *args, PyObject *kwargs) {
14286 PyObject *resultobj;
14287 wxDC *arg1 = (wxDC *) 0 ;
14288 int arg2 ;
14289 wxPoint *arg3 = (wxPoint *) 0 ;
14290 int arg4 = (int) 0 ;
14291 int arg5 = (int) 0 ;
14292 PyObject * obj0 = 0 ;
14293 PyObject * obj1 = 0 ;
14294 PyObject * obj2 = 0 ;
14295 PyObject * obj3 = 0 ;
14296 char *kwnames[] = {
14297 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset", NULL
14298 };
14299
14300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DC_DrawLines",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14302 if (SWIG_arg_fail(1)) SWIG_fail;
14303 {
14304 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14305 if (arg3 == NULL) SWIG_fail;
14306 }
14307 if (obj2) {
14308 {
14309 arg4 = (int)(SWIG_As_int(obj2));
14310 if (SWIG_arg_fail(4)) SWIG_fail;
14311 }
14312 }
14313 if (obj3) {
14314 {
14315 arg5 = (int)(SWIG_As_int(obj3));
14316 if (SWIG_arg_fail(5)) SWIG_fail;
14317 }
14318 }
14319 {
14320 PyThreadState* __tstate = wxPyBeginAllowThreads();
14321 (arg1)->DrawLines(arg2,arg3,arg4,arg5);
14322
14323 wxPyEndAllowThreads(__tstate);
14324 if (PyErr_Occurred()) SWIG_fail;
14325 }
14326 Py_INCREF(Py_None); resultobj = Py_None;
14327 {
14328 if (arg3) delete [] arg3;
14329 }
14330 return resultobj;
14331 fail:
14332 {
14333 if (arg3) delete [] arg3;
14334 }
14335 return NULL;
14336 }
14337
14338
14339 static PyObject *_wrap_DC_DrawPolygon(PyObject *, PyObject *args, PyObject *kwargs) {
14340 PyObject *resultobj;
14341 wxDC *arg1 = (wxDC *) 0 ;
14342 int arg2 ;
14343 wxPoint *arg3 = (wxPoint *) 0 ;
14344 int arg4 = (int) 0 ;
14345 int arg5 = (int) 0 ;
14346 int arg6 = (int) wxODDEVEN_RULE ;
14347 PyObject * obj0 = 0 ;
14348 PyObject * obj1 = 0 ;
14349 PyObject * obj2 = 0 ;
14350 PyObject * obj3 = 0 ;
14351 PyObject * obj4 = 0 ;
14352 char *kwnames[] = {
14353 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset",(char *) "fillStyle", NULL
14354 };
14355
14356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DC_DrawPolygon",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14358 if (SWIG_arg_fail(1)) SWIG_fail;
14359 {
14360 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14361 if (arg3 == NULL) SWIG_fail;
14362 }
14363 if (obj2) {
14364 {
14365 arg4 = (int)(SWIG_As_int(obj2));
14366 if (SWIG_arg_fail(4)) SWIG_fail;
14367 }
14368 }
14369 if (obj3) {
14370 {
14371 arg5 = (int)(SWIG_As_int(obj3));
14372 if (SWIG_arg_fail(5)) SWIG_fail;
14373 }
14374 }
14375 if (obj4) {
14376 {
14377 arg6 = (int)(SWIG_As_int(obj4));
14378 if (SWIG_arg_fail(6)) SWIG_fail;
14379 }
14380 }
14381 {
14382 PyThreadState* __tstate = wxPyBeginAllowThreads();
14383 (arg1)->DrawPolygon(arg2,arg3,arg4,arg5,arg6);
14384
14385 wxPyEndAllowThreads(__tstate);
14386 if (PyErr_Occurred()) SWIG_fail;
14387 }
14388 Py_INCREF(Py_None); resultobj = Py_None;
14389 {
14390 if (arg3) delete [] arg3;
14391 }
14392 return resultobj;
14393 fail:
14394 {
14395 if (arg3) delete [] arg3;
14396 }
14397 return NULL;
14398 }
14399
14400
14401 static PyObject *_wrap_DC_DrawLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14402 PyObject *resultobj;
14403 wxDC *arg1 = (wxDC *) 0 ;
14404 wxString *arg2 = 0 ;
14405 wxRect *arg3 = 0 ;
14406 int arg4 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14407 int arg5 = (int) -1 ;
14408 bool temp2 = false ;
14409 wxRect temp3 ;
14410 PyObject * obj0 = 0 ;
14411 PyObject * obj1 = 0 ;
14412 PyObject * obj2 = 0 ;
14413 PyObject * obj3 = 0 ;
14414 PyObject * obj4 = 0 ;
14415 char *kwnames[] = {
14416 (char *) "self",(char *) "text",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
14417 };
14418
14419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:DC_DrawLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14421 if (SWIG_arg_fail(1)) SWIG_fail;
14422 {
14423 arg2 = wxString_in_helper(obj1);
14424 if (arg2 == NULL) SWIG_fail;
14425 temp2 = true;
14426 }
14427 {
14428 arg3 = &temp3;
14429 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
14430 }
14431 if (obj3) {
14432 {
14433 arg4 = (int)(SWIG_As_int(obj3));
14434 if (SWIG_arg_fail(4)) SWIG_fail;
14435 }
14436 }
14437 if (obj4) {
14438 {
14439 arg5 = (int)(SWIG_As_int(obj4));
14440 if (SWIG_arg_fail(5)) SWIG_fail;
14441 }
14442 }
14443 {
14444 PyThreadState* __tstate = wxPyBeginAllowThreads();
14445 (arg1)->DrawLabel((wxString const &)*arg2,(wxRect const &)*arg3,arg4,arg5);
14446
14447 wxPyEndAllowThreads(__tstate);
14448 if (PyErr_Occurred()) SWIG_fail;
14449 }
14450 Py_INCREF(Py_None); resultobj = Py_None;
14451 {
14452 if (temp2)
14453 delete arg2;
14454 }
14455 return resultobj;
14456 fail:
14457 {
14458 if (temp2)
14459 delete arg2;
14460 }
14461 return NULL;
14462 }
14463
14464
14465 static PyObject *_wrap_DC_DrawImageLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14466 PyObject *resultobj;
14467 wxDC *arg1 = (wxDC *) 0 ;
14468 wxString *arg2 = 0 ;
14469 wxBitmap *arg3 = 0 ;
14470 wxRect *arg4 = 0 ;
14471 int arg5 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14472 int arg6 = (int) -1 ;
14473 wxRect result;
14474 bool temp2 = false ;
14475 wxRect temp4 ;
14476 PyObject * obj0 = 0 ;
14477 PyObject * obj1 = 0 ;
14478 PyObject * obj2 = 0 ;
14479 PyObject * obj3 = 0 ;
14480 PyObject * obj4 = 0 ;
14481 PyObject * obj5 = 0 ;
14482 char *kwnames[] = {
14483 (char *) "self",(char *) "text",(char *) "image",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
14484 };
14485
14486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:DC_DrawImageLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
14487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14488 if (SWIG_arg_fail(1)) SWIG_fail;
14489 {
14490 arg2 = wxString_in_helper(obj1);
14491 if (arg2 == NULL) SWIG_fail;
14492 temp2 = true;
14493 }
14494 {
14495 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
14496 if (SWIG_arg_fail(3)) SWIG_fail;
14497 if (arg3 == NULL) {
14498 SWIG_null_ref("wxBitmap");
14499 }
14500 if (SWIG_arg_fail(3)) SWIG_fail;
14501 }
14502 {
14503 arg4 = &temp4;
14504 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
14505 }
14506 if (obj4) {
14507 {
14508 arg5 = (int)(SWIG_As_int(obj4));
14509 if (SWIG_arg_fail(5)) SWIG_fail;
14510 }
14511 }
14512 if (obj5) {
14513 {
14514 arg6 = (int)(SWIG_As_int(obj5));
14515 if (SWIG_arg_fail(6)) SWIG_fail;
14516 }
14517 }
14518 {
14519 PyThreadState* __tstate = wxPyBeginAllowThreads();
14520 result = wxDC_DrawImageLabel(arg1,(wxString const &)*arg2,(wxBitmap const &)*arg3,(wxRect const &)*arg4,arg5,arg6);
14521
14522 wxPyEndAllowThreads(__tstate);
14523 if (PyErr_Occurred()) SWIG_fail;
14524 }
14525 {
14526 wxRect * resultptr;
14527 resultptr = new wxRect((wxRect &)(result));
14528 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
14529 }
14530 {
14531 if (temp2)
14532 delete arg2;
14533 }
14534 return resultobj;
14535 fail:
14536 {
14537 if (temp2)
14538 delete arg2;
14539 }
14540 return NULL;
14541 }
14542
14543
14544 static PyObject *_wrap_DC_DrawSpline(PyObject *, PyObject *args, PyObject *kwargs) {
14545 PyObject *resultobj;
14546 wxDC *arg1 = (wxDC *) 0 ;
14547 int arg2 ;
14548 wxPoint *arg3 = (wxPoint *) 0 ;
14549 PyObject * obj0 = 0 ;
14550 PyObject * obj1 = 0 ;
14551 char *kwnames[] = {
14552 (char *) "self",(char *) "points", NULL
14553 };
14554
14555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawSpline",kwnames,&obj0,&obj1)) goto fail;
14556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14557 if (SWIG_arg_fail(1)) SWIG_fail;
14558 {
14559 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14560 if (arg3 == NULL) SWIG_fail;
14561 }
14562 {
14563 PyThreadState* __tstate = wxPyBeginAllowThreads();
14564 (arg1)->DrawSpline(arg2,arg3);
14565
14566 wxPyEndAllowThreads(__tstate);
14567 if (PyErr_Occurred()) SWIG_fail;
14568 }
14569 Py_INCREF(Py_None); resultobj = Py_None;
14570 {
14571 if (arg3) delete [] arg3;
14572 }
14573 return resultobj;
14574 fail:
14575 {
14576 if (arg3) delete [] arg3;
14577 }
14578 return NULL;
14579 }
14580
14581
14582 static PyObject *_wrap_DC_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
14583 PyObject *resultobj;
14584 wxDC *arg1 = (wxDC *) 0 ;
14585 PyObject * obj0 = 0 ;
14586 char *kwnames[] = {
14587 (char *) "self", NULL
14588 };
14589
14590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Clear",kwnames,&obj0)) goto fail;
14591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14592 if (SWIG_arg_fail(1)) SWIG_fail;
14593 {
14594 PyThreadState* __tstate = wxPyBeginAllowThreads();
14595 (arg1)->Clear();
14596
14597 wxPyEndAllowThreads(__tstate);
14598 if (PyErr_Occurred()) SWIG_fail;
14599 }
14600 Py_INCREF(Py_None); resultobj = Py_None;
14601 return resultobj;
14602 fail:
14603 return NULL;
14604 }
14605
14606
14607 static PyObject *_wrap_DC_StartDoc(PyObject *, PyObject *args, PyObject *kwargs) {
14608 PyObject *resultobj;
14609 wxDC *arg1 = (wxDC *) 0 ;
14610 wxString *arg2 = 0 ;
14611 bool result;
14612 bool temp2 = false ;
14613 PyObject * obj0 = 0 ;
14614 PyObject * obj1 = 0 ;
14615 char *kwnames[] = {
14616 (char *) "self",(char *) "message", NULL
14617 };
14618
14619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_StartDoc",kwnames,&obj0,&obj1)) goto fail;
14620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14621 if (SWIG_arg_fail(1)) SWIG_fail;
14622 {
14623 arg2 = wxString_in_helper(obj1);
14624 if (arg2 == NULL) SWIG_fail;
14625 temp2 = true;
14626 }
14627 {
14628 PyThreadState* __tstate = wxPyBeginAllowThreads();
14629 result = (bool)(arg1)->StartDoc((wxString const &)*arg2);
14630
14631 wxPyEndAllowThreads(__tstate);
14632 if (PyErr_Occurred()) SWIG_fail;
14633 }
14634 {
14635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14636 }
14637 {
14638 if (temp2)
14639 delete arg2;
14640 }
14641 return resultobj;
14642 fail:
14643 {
14644 if (temp2)
14645 delete arg2;
14646 }
14647 return NULL;
14648 }
14649
14650
14651 static PyObject *_wrap_DC_EndDoc(PyObject *, PyObject *args, PyObject *kwargs) {
14652 PyObject *resultobj;
14653 wxDC *arg1 = (wxDC *) 0 ;
14654 PyObject * obj0 = 0 ;
14655 char *kwnames[] = {
14656 (char *) "self", NULL
14657 };
14658
14659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDoc",kwnames,&obj0)) goto fail;
14660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14661 if (SWIG_arg_fail(1)) SWIG_fail;
14662 {
14663 PyThreadState* __tstate = wxPyBeginAllowThreads();
14664 (arg1)->EndDoc();
14665
14666 wxPyEndAllowThreads(__tstate);
14667 if (PyErr_Occurred()) SWIG_fail;
14668 }
14669 Py_INCREF(Py_None); resultobj = Py_None;
14670 return resultobj;
14671 fail:
14672 return NULL;
14673 }
14674
14675
14676 static PyObject *_wrap_DC_StartPage(PyObject *, PyObject *args, PyObject *kwargs) {
14677 PyObject *resultobj;
14678 wxDC *arg1 = (wxDC *) 0 ;
14679 PyObject * obj0 = 0 ;
14680 char *kwnames[] = {
14681 (char *) "self", NULL
14682 };
14683
14684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_StartPage",kwnames,&obj0)) goto fail;
14685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14686 if (SWIG_arg_fail(1)) SWIG_fail;
14687 {
14688 PyThreadState* __tstate = wxPyBeginAllowThreads();
14689 (arg1)->StartPage();
14690
14691 wxPyEndAllowThreads(__tstate);
14692 if (PyErr_Occurred()) SWIG_fail;
14693 }
14694 Py_INCREF(Py_None); resultobj = Py_None;
14695 return resultobj;
14696 fail:
14697 return NULL;
14698 }
14699
14700
14701 static PyObject *_wrap_DC_EndPage(PyObject *, PyObject *args, PyObject *kwargs) {
14702 PyObject *resultobj;
14703 wxDC *arg1 = (wxDC *) 0 ;
14704 PyObject * obj0 = 0 ;
14705 char *kwnames[] = {
14706 (char *) "self", NULL
14707 };
14708
14709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndPage",kwnames,&obj0)) goto fail;
14710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14711 if (SWIG_arg_fail(1)) SWIG_fail;
14712 {
14713 PyThreadState* __tstate = wxPyBeginAllowThreads();
14714 (arg1)->EndPage();
14715
14716 wxPyEndAllowThreads(__tstate);
14717 if (PyErr_Occurred()) SWIG_fail;
14718 }
14719 Py_INCREF(Py_None); resultobj = Py_None;
14720 return resultobj;
14721 fail:
14722 return NULL;
14723 }
14724
14725
14726 static PyObject *_wrap_DC_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
14727 PyObject *resultobj;
14728 wxDC *arg1 = (wxDC *) 0 ;
14729 wxFont *arg2 = 0 ;
14730 PyObject * obj0 = 0 ;
14731 PyObject * obj1 = 0 ;
14732 char *kwnames[] = {
14733 (char *) "self",(char *) "font", NULL
14734 };
14735
14736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetFont",kwnames,&obj0,&obj1)) goto fail;
14737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14738 if (SWIG_arg_fail(1)) SWIG_fail;
14739 {
14740 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
14741 if (SWIG_arg_fail(2)) SWIG_fail;
14742 if (arg2 == NULL) {
14743 SWIG_null_ref("wxFont");
14744 }
14745 if (SWIG_arg_fail(2)) SWIG_fail;
14746 }
14747 {
14748 PyThreadState* __tstate = wxPyBeginAllowThreads();
14749 (arg1)->SetFont((wxFont const &)*arg2);
14750
14751 wxPyEndAllowThreads(__tstate);
14752 if (PyErr_Occurred()) SWIG_fail;
14753 }
14754 Py_INCREF(Py_None); resultobj = Py_None;
14755 return resultobj;
14756 fail:
14757 return NULL;
14758 }
14759
14760
14761 static PyObject *_wrap_DC_SetPen(PyObject *, PyObject *args, PyObject *kwargs) {
14762 PyObject *resultobj;
14763 wxDC *arg1 = (wxDC *) 0 ;
14764 wxPen *arg2 = 0 ;
14765 PyObject * obj0 = 0 ;
14766 PyObject * obj1 = 0 ;
14767 char *kwnames[] = {
14768 (char *) "self",(char *) "pen", NULL
14769 };
14770
14771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPen",kwnames,&obj0,&obj1)) goto fail;
14772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14773 if (SWIG_arg_fail(1)) SWIG_fail;
14774 {
14775 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
14776 if (SWIG_arg_fail(2)) SWIG_fail;
14777 if (arg2 == NULL) {
14778 SWIG_null_ref("wxPen");
14779 }
14780 if (SWIG_arg_fail(2)) SWIG_fail;
14781 }
14782 {
14783 PyThreadState* __tstate = wxPyBeginAllowThreads();
14784 (arg1)->SetPen((wxPen const &)*arg2);
14785
14786 wxPyEndAllowThreads(__tstate);
14787 if (PyErr_Occurred()) SWIG_fail;
14788 }
14789 Py_INCREF(Py_None); resultobj = Py_None;
14790 return resultobj;
14791 fail:
14792 return NULL;
14793 }
14794
14795
14796 static PyObject *_wrap_DC_SetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
14797 PyObject *resultobj;
14798 wxDC *arg1 = (wxDC *) 0 ;
14799 wxBrush *arg2 = 0 ;
14800 PyObject * obj0 = 0 ;
14801 PyObject * obj1 = 0 ;
14802 char *kwnames[] = {
14803 (char *) "self",(char *) "brush", NULL
14804 };
14805
14806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBrush",kwnames,&obj0,&obj1)) goto fail;
14807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14808 if (SWIG_arg_fail(1)) SWIG_fail;
14809 {
14810 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
14811 if (SWIG_arg_fail(2)) SWIG_fail;
14812 if (arg2 == NULL) {
14813 SWIG_null_ref("wxBrush");
14814 }
14815 if (SWIG_arg_fail(2)) SWIG_fail;
14816 }
14817 {
14818 PyThreadState* __tstate = wxPyBeginAllowThreads();
14819 (arg1)->SetBrush((wxBrush const &)*arg2);
14820
14821 wxPyEndAllowThreads(__tstate);
14822 if (PyErr_Occurred()) SWIG_fail;
14823 }
14824 Py_INCREF(Py_None); resultobj = Py_None;
14825 return resultobj;
14826 fail:
14827 return NULL;
14828 }
14829
14830
14831 static PyObject *_wrap_DC_SetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
14832 PyObject *resultobj;
14833 wxDC *arg1 = (wxDC *) 0 ;
14834 wxBrush *arg2 = 0 ;
14835 PyObject * obj0 = 0 ;
14836 PyObject * obj1 = 0 ;
14837 char *kwnames[] = {
14838 (char *) "self",(char *) "brush", NULL
14839 };
14840
14841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackground",kwnames,&obj0,&obj1)) goto fail;
14842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14843 if (SWIG_arg_fail(1)) SWIG_fail;
14844 {
14845 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
14846 if (SWIG_arg_fail(2)) SWIG_fail;
14847 if (arg2 == NULL) {
14848 SWIG_null_ref("wxBrush");
14849 }
14850 if (SWIG_arg_fail(2)) SWIG_fail;
14851 }
14852 {
14853 PyThreadState* __tstate = wxPyBeginAllowThreads();
14854 (arg1)->SetBackground((wxBrush const &)*arg2);
14855
14856 wxPyEndAllowThreads(__tstate);
14857 if (PyErr_Occurred()) SWIG_fail;
14858 }
14859 Py_INCREF(Py_None); resultobj = Py_None;
14860 return resultobj;
14861 fail:
14862 return NULL;
14863 }
14864
14865
14866 static PyObject *_wrap_DC_SetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
14867 PyObject *resultobj;
14868 wxDC *arg1 = (wxDC *) 0 ;
14869 int arg2 ;
14870 PyObject * obj0 = 0 ;
14871 PyObject * obj1 = 0 ;
14872 char *kwnames[] = {
14873 (char *) "self",(char *) "mode", NULL
14874 };
14875
14876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackgroundMode",kwnames,&obj0,&obj1)) goto fail;
14877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14878 if (SWIG_arg_fail(1)) SWIG_fail;
14879 {
14880 arg2 = (int)(SWIG_As_int(obj1));
14881 if (SWIG_arg_fail(2)) SWIG_fail;
14882 }
14883 {
14884 PyThreadState* __tstate = wxPyBeginAllowThreads();
14885 (arg1)->SetBackgroundMode(arg2);
14886
14887 wxPyEndAllowThreads(__tstate);
14888 if (PyErr_Occurred()) SWIG_fail;
14889 }
14890 Py_INCREF(Py_None); resultobj = Py_None;
14891 return resultobj;
14892 fail:
14893 return NULL;
14894 }
14895
14896
14897 static PyObject *_wrap_DC_SetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
14898 PyObject *resultobj;
14899 wxDC *arg1 = (wxDC *) 0 ;
14900 wxPalette *arg2 = 0 ;
14901 PyObject * obj0 = 0 ;
14902 PyObject * obj1 = 0 ;
14903 char *kwnames[] = {
14904 (char *) "self",(char *) "palette", NULL
14905 };
14906
14907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPalette",kwnames,&obj0,&obj1)) goto fail;
14908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14909 if (SWIG_arg_fail(1)) SWIG_fail;
14910 {
14911 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
14912 if (SWIG_arg_fail(2)) SWIG_fail;
14913 if (arg2 == NULL) {
14914 SWIG_null_ref("wxPalette");
14915 }
14916 if (SWIG_arg_fail(2)) SWIG_fail;
14917 }
14918 {
14919 PyThreadState* __tstate = wxPyBeginAllowThreads();
14920 (arg1)->SetPalette((wxPalette const &)*arg2);
14921
14922 wxPyEndAllowThreads(__tstate);
14923 if (PyErr_Occurred()) SWIG_fail;
14924 }
14925 Py_INCREF(Py_None); resultobj = Py_None;
14926 return resultobj;
14927 fail:
14928 return NULL;
14929 }
14930
14931
14932 static PyObject *_wrap_DC_DestroyClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14933 PyObject *resultobj;
14934 wxDC *arg1 = (wxDC *) 0 ;
14935 PyObject * obj0 = 0 ;
14936 char *kwnames[] = {
14937 (char *) "self", NULL
14938 };
14939
14940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_DestroyClippingRegion",kwnames,&obj0)) goto fail;
14941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14942 if (SWIG_arg_fail(1)) SWIG_fail;
14943 {
14944 PyThreadState* __tstate = wxPyBeginAllowThreads();
14945 (arg1)->DestroyClippingRegion();
14946
14947 wxPyEndAllowThreads(__tstate);
14948 if (PyErr_Occurred()) SWIG_fail;
14949 }
14950 Py_INCREF(Py_None); resultobj = Py_None;
14951 return resultobj;
14952 fail:
14953 return NULL;
14954 }
14955
14956
14957 static PyObject *_wrap_DC_GetClippingBox(PyObject *, PyObject *args, PyObject *kwargs) {
14958 PyObject *resultobj;
14959 wxDC *arg1 = (wxDC *) 0 ;
14960 int *arg2 = (int *) 0 ;
14961 int *arg3 = (int *) 0 ;
14962 int *arg4 = (int *) 0 ;
14963 int *arg5 = (int *) 0 ;
14964 int temp2 ;
14965 int res2 = 0 ;
14966 int temp3 ;
14967 int res3 = 0 ;
14968 int temp4 ;
14969 int res4 = 0 ;
14970 int temp5 ;
14971 int res5 = 0 ;
14972 PyObject * obj0 = 0 ;
14973 char *kwnames[] = {
14974 (char *) "self", NULL
14975 };
14976
14977 arg2 = &temp2; res2 = SWIG_NEWOBJ;
14978 arg3 = &temp3; res3 = SWIG_NEWOBJ;
14979 arg4 = &temp4; res4 = SWIG_NEWOBJ;
14980 arg5 = &temp5; res5 = SWIG_NEWOBJ;
14981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingBox",kwnames,&obj0)) goto fail;
14982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14983 if (SWIG_arg_fail(1)) SWIG_fail;
14984 {
14985 PyThreadState* __tstate = wxPyBeginAllowThreads();
14986 ((wxDC const *)arg1)->GetClippingBox(arg2,arg3,arg4,arg5);
14987
14988 wxPyEndAllowThreads(__tstate);
14989 if (PyErr_Occurred()) SWIG_fail;
14990 }
14991 Py_INCREF(Py_None); resultobj = Py_None;
14992 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
14993 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
14994 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
14995 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
14996 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
14997 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
14998 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
14999 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15000 return resultobj;
15001 fail:
15002 return NULL;
15003 }
15004
15005
15006 static PyObject *_wrap_DC_GetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
15007 PyObject *resultobj;
15008 wxDC *arg1 = (wxDC *) 0 ;
15009 wxRect result;
15010 PyObject * obj0 = 0 ;
15011 char *kwnames[] = {
15012 (char *) "self", NULL
15013 };
15014
15015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingRect",kwnames,&obj0)) goto fail;
15016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15017 if (SWIG_arg_fail(1)) SWIG_fail;
15018 {
15019 PyThreadState* __tstate = wxPyBeginAllowThreads();
15020 result = wxDC_GetClippingRect(arg1);
15021
15022 wxPyEndAllowThreads(__tstate);
15023 if (PyErr_Occurred()) SWIG_fail;
15024 }
15025 {
15026 wxRect * resultptr;
15027 resultptr = new wxRect((wxRect &)(result));
15028 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
15029 }
15030 return resultobj;
15031 fail:
15032 return NULL;
15033 }
15034
15035
15036 static PyObject *_wrap_DC_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
15037 PyObject *resultobj;
15038 wxDC *arg1 = (wxDC *) 0 ;
15039 int result;
15040 PyObject * obj0 = 0 ;
15041 char *kwnames[] = {
15042 (char *) "self", NULL
15043 };
15044
15045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharHeight",kwnames,&obj0)) goto fail;
15046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15047 if (SWIG_arg_fail(1)) SWIG_fail;
15048 {
15049 PyThreadState* __tstate = wxPyBeginAllowThreads();
15050 result = (int)((wxDC const *)arg1)->GetCharHeight();
15051
15052 wxPyEndAllowThreads(__tstate);
15053 if (PyErr_Occurred()) SWIG_fail;
15054 }
15055 {
15056 resultobj = SWIG_From_int((int)(result));
15057 }
15058 return resultobj;
15059 fail:
15060 return NULL;
15061 }
15062
15063
15064 static PyObject *_wrap_DC_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
15065 PyObject *resultobj;
15066 wxDC *arg1 = (wxDC *) 0 ;
15067 int result;
15068 PyObject * obj0 = 0 ;
15069 char *kwnames[] = {
15070 (char *) "self", NULL
15071 };
15072
15073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharWidth",kwnames,&obj0)) goto fail;
15074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15075 if (SWIG_arg_fail(1)) SWIG_fail;
15076 {
15077 PyThreadState* __tstate = wxPyBeginAllowThreads();
15078 result = (int)((wxDC const *)arg1)->GetCharWidth();
15079
15080 wxPyEndAllowThreads(__tstate);
15081 if (PyErr_Occurred()) SWIG_fail;
15082 }
15083 {
15084 resultobj = SWIG_From_int((int)(result));
15085 }
15086 return resultobj;
15087 fail:
15088 return NULL;
15089 }
15090
15091
15092 static PyObject *_wrap_DC_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15093 PyObject *resultobj;
15094 wxDC *arg1 = (wxDC *) 0 ;
15095 wxString *arg2 = 0 ;
15096 int *arg3 = (int *) 0 ;
15097 int *arg4 = (int *) 0 ;
15098 bool temp2 = false ;
15099 int temp3 ;
15100 int res3 = 0 ;
15101 int temp4 ;
15102 int res4 = 0 ;
15103 PyObject * obj0 = 0 ;
15104 PyObject * obj1 = 0 ;
15105 char *kwnames[] = {
15106 (char *) "self",(char *) "string", NULL
15107 };
15108
15109 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15110 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
15112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15113 if (SWIG_arg_fail(1)) SWIG_fail;
15114 {
15115 arg2 = wxString_in_helper(obj1);
15116 if (arg2 == NULL) SWIG_fail;
15117 temp2 = true;
15118 }
15119 {
15120 PyThreadState* __tstate = wxPyBeginAllowThreads();
15121 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
15122
15123 wxPyEndAllowThreads(__tstate);
15124 if (PyErr_Occurred()) SWIG_fail;
15125 }
15126 Py_INCREF(Py_None); resultobj = Py_None;
15127 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15128 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15129 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15130 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15131 {
15132 if (temp2)
15133 delete arg2;
15134 }
15135 return resultobj;
15136 fail:
15137 {
15138 if (temp2)
15139 delete arg2;
15140 }
15141 return NULL;
15142 }
15143
15144
15145 static PyObject *_wrap_DC_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15146 PyObject *resultobj;
15147 wxDC *arg1 = (wxDC *) 0 ;
15148 wxString *arg2 = 0 ;
15149 int *arg3 = (int *) 0 ;
15150 int *arg4 = (int *) 0 ;
15151 int *arg5 = (int *) 0 ;
15152 int *arg6 = (int *) 0 ;
15153 wxFont *arg7 = (wxFont *) NULL ;
15154 bool temp2 = false ;
15155 int temp3 ;
15156 int res3 = 0 ;
15157 int temp4 ;
15158 int res4 = 0 ;
15159 int temp5 ;
15160 int res5 = 0 ;
15161 int temp6 ;
15162 int res6 = 0 ;
15163 PyObject * obj0 = 0 ;
15164 PyObject * obj1 = 0 ;
15165 PyObject * obj2 = 0 ;
15166 char *kwnames[] = {
15167 (char *) "self",(char *) "string",(char *) "font", NULL
15168 };
15169
15170 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15171 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15172 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15173 arg6 = &temp6; res6 = SWIG_NEWOBJ;
15174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15176 if (SWIG_arg_fail(1)) SWIG_fail;
15177 {
15178 arg2 = wxString_in_helper(obj1);
15179 if (arg2 == NULL) SWIG_fail;
15180 temp2 = true;
15181 }
15182 if (obj2) {
15183 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15184 if (SWIG_arg_fail(7)) SWIG_fail;
15185 }
15186 {
15187 PyThreadState* __tstate = wxPyBeginAllowThreads();
15188 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
15189
15190 wxPyEndAllowThreads(__tstate);
15191 if (PyErr_Occurred()) SWIG_fail;
15192 }
15193 Py_INCREF(Py_None); resultobj = Py_None;
15194 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15195 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15196 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15197 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15198 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15199 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15200 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
15201 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
15202 {
15203 if (temp2)
15204 delete arg2;
15205 }
15206 return resultobj;
15207 fail:
15208 {
15209 if (temp2)
15210 delete arg2;
15211 }
15212 return NULL;
15213 }
15214
15215
15216 static PyObject *_wrap_DC_GetMultiLineTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15217 PyObject *resultobj;
15218 wxDC *arg1 = (wxDC *) 0 ;
15219 wxString *arg2 = 0 ;
15220 int *arg3 = (int *) 0 ;
15221 int *arg4 = (int *) 0 ;
15222 int *arg5 = (int *) 0 ;
15223 wxFont *arg6 = (wxFont *) NULL ;
15224 bool temp2 = false ;
15225 int temp3 ;
15226 int res3 = 0 ;
15227 int temp4 ;
15228 int res4 = 0 ;
15229 int temp5 ;
15230 int res5 = 0 ;
15231 PyObject * obj0 = 0 ;
15232 PyObject * obj1 = 0 ;
15233 PyObject * obj2 = 0 ;
15234 char *kwnames[] = {
15235 (char *) "self",(char *) "text",(char *) "font", NULL
15236 };
15237
15238 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15239 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15240 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetMultiLineTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15243 if (SWIG_arg_fail(1)) SWIG_fail;
15244 {
15245 arg2 = wxString_in_helper(obj1);
15246 if (arg2 == NULL) SWIG_fail;
15247 temp2 = true;
15248 }
15249 if (obj2) {
15250 SWIG_Python_ConvertPtr(obj2, (void **)&arg6, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15251 if (SWIG_arg_fail(6)) SWIG_fail;
15252 }
15253 {
15254 PyThreadState* __tstate = wxPyBeginAllowThreads();
15255 (arg1)->GetMultiLineTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6);
15256
15257 wxPyEndAllowThreads(__tstate);
15258 if (PyErr_Occurred()) SWIG_fail;
15259 }
15260 Py_INCREF(Py_None); resultobj = Py_None;
15261 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15262 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15263 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15264 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15265 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15266 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15267 {
15268 if (temp2)
15269 delete arg2;
15270 }
15271 return resultobj;
15272 fail:
15273 {
15274 if (temp2)
15275 delete arg2;
15276 }
15277 return NULL;
15278 }
15279
15280
15281 static PyObject *_wrap_DC_GetPartialTextExtents(PyObject *, PyObject *args, PyObject *kwargs) {
15282 PyObject *resultobj;
15283 wxDC *arg1 = (wxDC *) 0 ;
15284 wxString *arg2 = 0 ;
15285 wxArrayInt result;
15286 bool temp2 = false ;
15287 PyObject * obj0 = 0 ;
15288 PyObject * obj1 = 0 ;
15289 char *kwnames[] = {
15290 (char *) "self",(char *) "text", NULL
15291 };
15292
15293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPartialTextExtents",kwnames,&obj0,&obj1)) goto fail;
15294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15295 if (SWIG_arg_fail(1)) SWIG_fail;
15296 {
15297 arg2 = wxString_in_helper(obj1);
15298 if (arg2 == NULL) SWIG_fail;
15299 temp2 = true;
15300 }
15301 {
15302 PyThreadState* __tstate = wxPyBeginAllowThreads();
15303 result = wxDC_GetPartialTextExtents(arg1,(wxString const &)*arg2);
15304
15305 wxPyEndAllowThreads(__tstate);
15306 if (PyErr_Occurred()) SWIG_fail;
15307 }
15308 {
15309 resultobj = PyList_New(0);
15310 size_t idx;
15311 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15312 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15313 PyList_Append(resultobj, val);
15314 Py_DECREF(val);
15315 }
15316 }
15317 {
15318 if (temp2)
15319 delete arg2;
15320 }
15321 return resultobj;
15322 fail:
15323 {
15324 if (temp2)
15325 delete arg2;
15326 }
15327 return NULL;
15328 }
15329
15330
15331 static PyObject *_wrap_DC_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
15332 PyObject *resultobj;
15333 wxDC *arg1 = (wxDC *) 0 ;
15334 wxSize result;
15335 PyObject * obj0 = 0 ;
15336 char *kwnames[] = {
15337 (char *) "self", NULL
15338 };
15339
15340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSize",kwnames,&obj0)) goto fail;
15341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15342 if (SWIG_arg_fail(1)) SWIG_fail;
15343 {
15344 PyThreadState* __tstate = wxPyBeginAllowThreads();
15345 result = (arg1)->GetSize();
15346
15347 wxPyEndAllowThreads(__tstate);
15348 if (PyErr_Occurred()) SWIG_fail;
15349 }
15350 {
15351 wxSize * resultptr;
15352 resultptr = new wxSize((wxSize &)(result));
15353 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15354 }
15355 return resultobj;
15356 fail:
15357 return NULL;
15358 }
15359
15360
15361 static PyObject *_wrap_DC_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15362 PyObject *resultobj;
15363 wxDC *arg1 = (wxDC *) 0 ;
15364 int *arg2 = (int *) 0 ;
15365 int *arg3 = (int *) 0 ;
15366 int temp2 ;
15367 int res2 = 0 ;
15368 int temp3 ;
15369 int res3 = 0 ;
15370 PyObject * obj0 = 0 ;
15371 char *kwnames[] = {
15372 (char *) "self", NULL
15373 };
15374
15375 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15376 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeTuple",kwnames,&obj0)) goto fail;
15378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15379 if (SWIG_arg_fail(1)) SWIG_fail;
15380 {
15381 PyThreadState* __tstate = wxPyBeginAllowThreads();
15382 (arg1)->GetSize(arg2,arg3);
15383
15384 wxPyEndAllowThreads(__tstate);
15385 if (PyErr_Occurred()) SWIG_fail;
15386 }
15387 Py_INCREF(Py_None); resultobj = Py_None;
15388 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15389 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15390 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15391 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15392 return resultobj;
15393 fail:
15394 return NULL;
15395 }
15396
15397
15398 static PyObject *_wrap_DC_GetSizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
15399 PyObject *resultobj;
15400 wxDC *arg1 = (wxDC *) 0 ;
15401 wxSize result;
15402 PyObject * obj0 = 0 ;
15403 char *kwnames[] = {
15404 (char *) "self", NULL
15405 };
15406
15407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMM",kwnames,&obj0)) goto fail;
15408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15409 if (SWIG_arg_fail(1)) SWIG_fail;
15410 {
15411 PyThreadState* __tstate = wxPyBeginAllowThreads();
15412 result = ((wxDC const *)arg1)->GetSizeMM();
15413
15414 wxPyEndAllowThreads(__tstate);
15415 if (PyErr_Occurred()) SWIG_fail;
15416 }
15417 {
15418 wxSize * resultptr;
15419 resultptr = new wxSize((wxSize &)(result));
15420 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15421 }
15422 return resultobj;
15423 fail:
15424 return NULL;
15425 }
15426
15427
15428 static PyObject *_wrap_DC_GetSizeMMTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15429 PyObject *resultobj;
15430 wxDC *arg1 = (wxDC *) 0 ;
15431 int *arg2 = (int *) 0 ;
15432 int *arg3 = (int *) 0 ;
15433 int temp2 ;
15434 int res2 = 0 ;
15435 int temp3 ;
15436 int res3 = 0 ;
15437 PyObject * obj0 = 0 ;
15438 char *kwnames[] = {
15439 (char *) "self", NULL
15440 };
15441
15442 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15443 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMMTuple",kwnames,&obj0)) goto fail;
15445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15446 if (SWIG_arg_fail(1)) SWIG_fail;
15447 {
15448 PyThreadState* __tstate = wxPyBeginAllowThreads();
15449 ((wxDC const *)arg1)->GetSizeMM(arg2,arg3);
15450
15451 wxPyEndAllowThreads(__tstate);
15452 if (PyErr_Occurred()) SWIG_fail;
15453 }
15454 Py_INCREF(Py_None); resultobj = Py_None;
15455 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15456 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15457 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15458 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15459 return resultobj;
15460 fail:
15461 return NULL;
15462 }
15463
15464
15465 static PyObject *_wrap_DC_DeviceToLogicalX(PyObject *, PyObject *args, PyObject *kwargs) {
15466 PyObject *resultobj;
15467 wxDC *arg1 = (wxDC *) 0 ;
15468 int arg2 ;
15469 int result;
15470 PyObject * obj0 = 0 ;
15471 PyObject * obj1 = 0 ;
15472 char *kwnames[] = {
15473 (char *) "self",(char *) "x", NULL
15474 };
15475
15476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalX",kwnames,&obj0,&obj1)) goto fail;
15477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15478 if (SWIG_arg_fail(1)) SWIG_fail;
15479 {
15480 arg2 = (int)(SWIG_As_int(obj1));
15481 if (SWIG_arg_fail(2)) SWIG_fail;
15482 }
15483 {
15484 PyThreadState* __tstate = wxPyBeginAllowThreads();
15485 result = (int)((wxDC const *)arg1)->DeviceToLogicalX(arg2);
15486
15487 wxPyEndAllowThreads(__tstate);
15488 if (PyErr_Occurred()) SWIG_fail;
15489 }
15490 {
15491 resultobj = SWIG_From_int((int)(result));
15492 }
15493 return resultobj;
15494 fail:
15495 return NULL;
15496 }
15497
15498
15499 static PyObject *_wrap_DC_DeviceToLogicalY(PyObject *, PyObject *args, PyObject *kwargs) {
15500 PyObject *resultobj;
15501 wxDC *arg1 = (wxDC *) 0 ;
15502 int arg2 ;
15503 int result;
15504 PyObject * obj0 = 0 ;
15505 PyObject * obj1 = 0 ;
15506 char *kwnames[] = {
15507 (char *) "self",(char *) "y", NULL
15508 };
15509
15510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalY",kwnames,&obj0,&obj1)) goto fail;
15511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15512 if (SWIG_arg_fail(1)) SWIG_fail;
15513 {
15514 arg2 = (int)(SWIG_As_int(obj1));
15515 if (SWIG_arg_fail(2)) SWIG_fail;
15516 }
15517 {
15518 PyThreadState* __tstate = wxPyBeginAllowThreads();
15519 result = (int)((wxDC const *)arg1)->DeviceToLogicalY(arg2);
15520
15521 wxPyEndAllowThreads(__tstate);
15522 if (PyErr_Occurred()) SWIG_fail;
15523 }
15524 {
15525 resultobj = SWIG_From_int((int)(result));
15526 }
15527 return resultobj;
15528 fail:
15529 return NULL;
15530 }
15531
15532
15533 static PyObject *_wrap_DC_DeviceToLogicalXRel(PyObject *, PyObject *args, PyObject *kwargs) {
15534 PyObject *resultobj;
15535 wxDC *arg1 = (wxDC *) 0 ;
15536 int arg2 ;
15537 int result;
15538 PyObject * obj0 = 0 ;
15539 PyObject * obj1 = 0 ;
15540 char *kwnames[] = {
15541 (char *) "self",(char *) "x", NULL
15542 };
15543
15544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalXRel",kwnames,&obj0,&obj1)) goto fail;
15545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15546 if (SWIG_arg_fail(1)) SWIG_fail;
15547 {
15548 arg2 = (int)(SWIG_As_int(obj1));
15549 if (SWIG_arg_fail(2)) SWIG_fail;
15550 }
15551 {
15552 PyThreadState* __tstate = wxPyBeginAllowThreads();
15553 result = (int)((wxDC const *)arg1)->DeviceToLogicalXRel(arg2);
15554
15555 wxPyEndAllowThreads(__tstate);
15556 if (PyErr_Occurred()) SWIG_fail;
15557 }
15558 {
15559 resultobj = SWIG_From_int((int)(result));
15560 }
15561 return resultobj;
15562 fail:
15563 return NULL;
15564 }
15565
15566
15567 static PyObject *_wrap_DC_DeviceToLogicalYRel(PyObject *, PyObject *args, PyObject *kwargs) {
15568 PyObject *resultobj;
15569 wxDC *arg1 = (wxDC *) 0 ;
15570 int arg2 ;
15571 int result;
15572 PyObject * obj0 = 0 ;
15573 PyObject * obj1 = 0 ;
15574 char *kwnames[] = {
15575 (char *) "self",(char *) "y", NULL
15576 };
15577
15578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalYRel",kwnames,&obj0,&obj1)) goto fail;
15579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15580 if (SWIG_arg_fail(1)) SWIG_fail;
15581 {
15582 arg2 = (int)(SWIG_As_int(obj1));
15583 if (SWIG_arg_fail(2)) SWIG_fail;
15584 }
15585 {
15586 PyThreadState* __tstate = wxPyBeginAllowThreads();
15587 result = (int)((wxDC const *)arg1)->DeviceToLogicalYRel(arg2);
15588
15589 wxPyEndAllowThreads(__tstate);
15590 if (PyErr_Occurred()) SWIG_fail;
15591 }
15592 {
15593 resultobj = SWIG_From_int((int)(result));
15594 }
15595 return resultobj;
15596 fail:
15597 return NULL;
15598 }
15599
15600
15601 static PyObject *_wrap_DC_LogicalToDeviceX(PyObject *, PyObject *args, PyObject *kwargs) {
15602 PyObject *resultobj;
15603 wxDC *arg1 = (wxDC *) 0 ;
15604 int arg2 ;
15605 int result;
15606 PyObject * obj0 = 0 ;
15607 PyObject * obj1 = 0 ;
15608 char *kwnames[] = {
15609 (char *) "self",(char *) "x", NULL
15610 };
15611
15612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceX",kwnames,&obj0,&obj1)) goto fail;
15613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15614 if (SWIG_arg_fail(1)) SWIG_fail;
15615 {
15616 arg2 = (int)(SWIG_As_int(obj1));
15617 if (SWIG_arg_fail(2)) SWIG_fail;
15618 }
15619 {
15620 PyThreadState* __tstate = wxPyBeginAllowThreads();
15621 result = (int)((wxDC const *)arg1)->LogicalToDeviceX(arg2);
15622
15623 wxPyEndAllowThreads(__tstate);
15624 if (PyErr_Occurred()) SWIG_fail;
15625 }
15626 {
15627 resultobj = SWIG_From_int((int)(result));
15628 }
15629 return resultobj;
15630 fail:
15631 return NULL;
15632 }
15633
15634
15635 static PyObject *_wrap_DC_LogicalToDeviceY(PyObject *, PyObject *args, PyObject *kwargs) {
15636 PyObject *resultobj;
15637 wxDC *arg1 = (wxDC *) 0 ;
15638 int arg2 ;
15639 int result;
15640 PyObject * obj0 = 0 ;
15641 PyObject * obj1 = 0 ;
15642 char *kwnames[] = {
15643 (char *) "self",(char *) "y", NULL
15644 };
15645
15646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceY",kwnames,&obj0,&obj1)) goto fail;
15647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15648 if (SWIG_arg_fail(1)) SWIG_fail;
15649 {
15650 arg2 = (int)(SWIG_As_int(obj1));
15651 if (SWIG_arg_fail(2)) SWIG_fail;
15652 }
15653 {
15654 PyThreadState* __tstate = wxPyBeginAllowThreads();
15655 result = (int)((wxDC const *)arg1)->LogicalToDeviceY(arg2);
15656
15657 wxPyEndAllowThreads(__tstate);
15658 if (PyErr_Occurred()) SWIG_fail;
15659 }
15660 {
15661 resultobj = SWIG_From_int((int)(result));
15662 }
15663 return resultobj;
15664 fail:
15665 return NULL;
15666 }
15667
15668
15669 static PyObject *_wrap_DC_LogicalToDeviceXRel(PyObject *, PyObject *args, PyObject *kwargs) {
15670 PyObject *resultobj;
15671 wxDC *arg1 = (wxDC *) 0 ;
15672 int arg2 ;
15673 int result;
15674 PyObject * obj0 = 0 ;
15675 PyObject * obj1 = 0 ;
15676 char *kwnames[] = {
15677 (char *) "self",(char *) "x", NULL
15678 };
15679
15680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceXRel",kwnames,&obj0,&obj1)) goto fail;
15681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15682 if (SWIG_arg_fail(1)) SWIG_fail;
15683 {
15684 arg2 = (int)(SWIG_As_int(obj1));
15685 if (SWIG_arg_fail(2)) SWIG_fail;
15686 }
15687 {
15688 PyThreadState* __tstate = wxPyBeginAllowThreads();
15689 result = (int)((wxDC const *)arg1)->LogicalToDeviceXRel(arg2);
15690
15691 wxPyEndAllowThreads(__tstate);
15692 if (PyErr_Occurred()) SWIG_fail;
15693 }
15694 {
15695 resultobj = SWIG_From_int((int)(result));
15696 }
15697 return resultobj;
15698 fail:
15699 return NULL;
15700 }
15701
15702
15703 static PyObject *_wrap_DC_LogicalToDeviceYRel(PyObject *, PyObject *args, PyObject *kwargs) {
15704 PyObject *resultobj;
15705 wxDC *arg1 = (wxDC *) 0 ;
15706 int arg2 ;
15707 int result;
15708 PyObject * obj0 = 0 ;
15709 PyObject * obj1 = 0 ;
15710 char *kwnames[] = {
15711 (char *) "self",(char *) "y", NULL
15712 };
15713
15714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceYRel",kwnames,&obj0,&obj1)) goto fail;
15715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15716 if (SWIG_arg_fail(1)) SWIG_fail;
15717 {
15718 arg2 = (int)(SWIG_As_int(obj1));
15719 if (SWIG_arg_fail(2)) SWIG_fail;
15720 }
15721 {
15722 PyThreadState* __tstate = wxPyBeginAllowThreads();
15723 result = (int)((wxDC const *)arg1)->LogicalToDeviceYRel(arg2);
15724
15725 wxPyEndAllowThreads(__tstate);
15726 if (PyErr_Occurred()) SWIG_fail;
15727 }
15728 {
15729 resultobj = SWIG_From_int((int)(result));
15730 }
15731 return resultobj;
15732 fail:
15733 return NULL;
15734 }
15735
15736
15737 static PyObject *_wrap_DC_CanDrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
15738 PyObject *resultobj;
15739 wxDC *arg1 = (wxDC *) 0 ;
15740 bool result;
15741 PyObject * obj0 = 0 ;
15742 char *kwnames[] = {
15743 (char *) "self", NULL
15744 };
15745
15746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanDrawBitmap",kwnames,&obj0)) goto fail;
15747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15748 if (SWIG_arg_fail(1)) SWIG_fail;
15749 {
15750 PyThreadState* __tstate = wxPyBeginAllowThreads();
15751 result = (bool)((wxDC const *)arg1)->CanDrawBitmap();
15752
15753 wxPyEndAllowThreads(__tstate);
15754 if (PyErr_Occurred()) SWIG_fail;
15755 }
15756 {
15757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15758 }
15759 return resultobj;
15760 fail:
15761 return NULL;
15762 }
15763
15764
15765 static PyObject *_wrap_DC_CanGetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15766 PyObject *resultobj;
15767 wxDC *arg1 = (wxDC *) 0 ;
15768 bool result;
15769 PyObject * obj0 = 0 ;
15770 char *kwnames[] = {
15771 (char *) "self", NULL
15772 };
15773
15774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanGetTextExtent",kwnames,&obj0)) goto fail;
15775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15776 if (SWIG_arg_fail(1)) SWIG_fail;
15777 {
15778 PyThreadState* __tstate = wxPyBeginAllowThreads();
15779 result = (bool)((wxDC const *)arg1)->CanGetTextExtent();
15780
15781 wxPyEndAllowThreads(__tstate);
15782 if (PyErr_Occurred()) SWIG_fail;
15783 }
15784 {
15785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15786 }
15787 return resultobj;
15788 fail:
15789 return NULL;
15790 }
15791
15792
15793 static PyObject *_wrap_DC_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
15794 PyObject *resultobj;
15795 wxDC *arg1 = (wxDC *) 0 ;
15796 int result;
15797 PyObject * obj0 = 0 ;
15798 char *kwnames[] = {
15799 (char *) "self", NULL
15800 };
15801
15802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDepth",kwnames,&obj0)) goto fail;
15803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15804 if (SWIG_arg_fail(1)) SWIG_fail;
15805 {
15806 PyThreadState* __tstate = wxPyBeginAllowThreads();
15807 result = (int)((wxDC const *)arg1)->GetDepth();
15808
15809 wxPyEndAllowThreads(__tstate);
15810 if (PyErr_Occurred()) SWIG_fail;
15811 }
15812 {
15813 resultobj = SWIG_From_int((int)(result));
15814 }
15815 return resultobj;
15816 fail:
15817 return NULL;
15818 }
15819
15820
15821 static PyObject *_wrap_DC_GetPPI(PyObject *, PyObject *args, PyObject *kwargs) {
15822 PyObject *resultobj;
15823 wxDC *arg1 = (wxDC *) 0 ;
15824 wxSize result;
15825 PyObject * obj0 = 0 ;
15826 char *kwnames[] = {
15827 (char *) "self", NULL
15828 };
15829
15830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPPI",kwnames,&obj0)) goto fail;
15831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15832 if (SWIG_arg_fail(1)) SWIG_fail;
15833 {
15834 PyThreadState* __tstate = wxPyBeginAllowThreads();
15835 result = ((wxDC const *)arg1)->GetPPI();
15836
15837 wxPyEndAllowThreads(__tstate);
15838 if (PyErr_Occurred()) SWIG_fail;
15839 }
15840 {
15841 wxSize * resultptr;
15842 resultptr = new wxSize((wxSize &)(result));
15843 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15844 }
15845 return resultobj;
15846 fail:
15847 return NULL;
15848 }
15849
15850
15851 static PyObject *_wrap_DC_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
15852 PyObject *resultobj;
15853 wxDC *arg1 = (wxDC *) 0 ;
15854 bool result;
15855 PyObject * obj0 = 0 ;
15856 char *kwnames[] = {
15857 (char *) "self", NULL
15858 };
15859
15860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Ok",kwnames,&obj0)) goto fail;
15861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15862 if (SWIG_arg_fail(1)) SWIG_fail;
15863 {
15864 PyThreadState* __tstate = wxPyBeginAllowThreads();
15865 result = (bool)((wxDC const *)arg1)->Ok();
15866
15867 wxPyEndAllowThreads(__tstate);
15868 if (PyErr_Occurred()) SWIG_fail;
15869 }
15870 {
15871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15872 }
15873 return resultobj;
15874 fail:
15875 return NULL;
15876 }
15877
15878
15879 static PyObject *_wrap_DC_GetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
15880 PyObject *resultobj;
15881 wxDC *arg1 = (wxDC *) 0 ;
15882 int result;
15883 PyObject * obj0 = 0 ;
15884 char *kwnames[] = {
15885 (char *) "self", NULL
15886 };
15887
15888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackgroundMode",kwnames,&obj0)) goto fail;
15889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15890 if (SWIG_arg_fail(1)) SWIG_fail;
15891 {
15892 PyThreadState* __tstate = wxPyBeginAllowThreads();
15893 result = (int)((wxDC const *)arg1)->GetBackgroundMode();
15894
15895 wxPyEndAllowThreads(__tstate);
15896 if (PyErr_Occurred()) SWIG_fail;
15897 }
15898 {
15899 resultobj = SWIG_From_int((int)(result));
15900 }
15901 return resultobj;
15902 fail:
15903 return NULL;
15904 }
15905
15906
15907 static PyObject *_wrap_DC_GetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15908 PyObject *resultobj;
15909 wxDC *arg1 = (wxDC *) 0 ;
15910 wxBrush *result;
15911 PyObject * obj0 = 0 ;
15912 char *kwnames[] = {
15913 (char *) "self", NULL
15914 };
15915
15916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackground",kwnames,&obj0)) goto fail;
15917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15918 if (SWIG_arg_fail(1)) SWIG_fail;
15919 {
15920 PyThreadState* __tstate = wxPyBeginAllowThreads();
15921 {
15922 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBackground();
15923 result = (wxBrush *) &_result_ref;
15924 }
15925
15926 wxPyEndAllowThreads(__tstate);
15927 if (PyErr_Occurred()) SWIG_fail;
15928 }
15929 {
15930 wxBrush* resultptr = new wxBrush(*result);
15931 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
15932 }
15933 return resultobj;
15934 fail:
15935 return NULL;
15936 }
15937
15938
15939 static PyObject *_wrap_DC_GetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
15940 PyObject *resultobj;
15941 wxDC *arg1 = (wxDC *) 0 ;
15942 wxBrush *result;
15943 PyObject * obj0 = 0 ;
15944 char *kwnames[] = {
15945 (char *) "self", NULL
15946 };
15947
15948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBrush",kwnames,&obj0)) goto fail;
15949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15950 if (SWIG_arg_fail(1)) SWIG_fail;
15951 {
15952 PyThreadState* __tstate = wxPyBeginAllowThreads();
15953 {
15954 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBrush();
15955 result = (wxBrush *) &_result_ref;
15956 }
15957
15958 wxPyEndAllowThreads(__tstate);
15959 if (PyErr_Occurred()) SWIG_fail;
15960 }
15961 {
15962 wxBrush* resultptr = new wxBrush(*result);
15963 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
15964 }
15965 return resultobj;
15966 fail:
15967 return NULL;
15968 }
15969
15970
15971 static PyObject *_wrap_DC_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
15972 PyObject *resultobj;
15973 wxDC *arg1 = (wxDC *) 0 ;
15974 wxFont *result;
15975 PyObject * obj0 = 0 ;
15976 char *kwnames[] = {
15977 (char *) "self", NULL
15978 };
15979
15980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetFont",kwnames,&obj0)) goto fail;
15981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15982 if (SWIG_arg_fail(1)) SWIG_fail;
15983 {
15984 PyThreadState* __tstate = wxPyBeginAllowThreads();
15985 {
15986 wxFont const &_result_ref = ((wxDC const *)arg1)->GetFont();
15987 result = (wxFont *) &_result_ref;
15988 }
15989
15990 wxPyEndAllowThreads(__tstate);
15991 if (PyErr_Occurred()) SWIG_fail;
15992 }
15993 {
15994 wxFont* resultptr = new wxFont(*result);
15995 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxFont, 1);
15996 }
15997 return resultobj;
15998 fail:
15999 return NULL;
16000 }
16001
16002
16003 static PyObject *_wrap_DC_GetPen(PyObject *, PyObject *args, PyObject *kwargs) {
16004 PyObject *resultobj;
16005 wxDC *arg1 = (wxDC *) 0 ;
16006 wxPen *result;
16007 PyObject * obj0 = 0 ;
16008 char *kwnames[] = {
16009 (char *) "self", NULL
16010 };
16011
16012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPen",kwnames,&obj0)) goto fail;
16013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16014 if (SWIG_arg_fail(1)) SWIG_fail;
16015 {
16016 PyThreadState* __tstate = wxPyBeginAllowThreads();
16017 {
16018 wxPen const &_result_ref = ((wxDC const *)arg1)->GetPen();
16019 result = (wxPen *) &_result_ref;
16020 }
16021
16022 wxPyEndAllowThreads(__tstate);
16023 if (PyErr_Occurred()) SWIG_fail;
16024 }
16025 {
16026 wxPen* resultptr = new wxPen(*result);
16027 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxPen, 1);
16028 }
16029 return resultobj;
16030 fail:
16031 return NULL;
16032 }
16033
16034
16035 static PyObject *_wrap_DC_GetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16036 PyObject *resultobj;
16037 wxDC *arg1 = (wxDC *) 0 ;
16038 wxColour *result;
16039 PyObject * obj0 = 0 ;
16040 char *kwnames[] = {
16041 (char *) "self", NULL
16042 };
16043
16044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextBackground",kwnames,&obj0)) goto fail;
16045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16046 if (SWIG_arg_fail(1)) SWIG_fail;
16047 {
16048 PyThreadState* __tstate = wxPyBeginAllowThreads();
16049 {
16050 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextBackground();
16051 result = (wxColour *) &_result_ref;
16052 }
16053
16054 wxPyEndAllowThreads(__tstate);
16055 if (PyErr_Occurred()) SWIG_fail;
16056 }
16057 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
16058 return resultobj;
16059 fail:
16060 return NULL;
16061 }
16062
16063
16064 static PyObject *_wrap_DC_GetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16065 PyObject *resultobj;
16066 wxDC *arg1 = (wxDC *) 0 ;
16067 wxColour *result;
16068 PyObject * obj0 = 0 ;
16069 char *kwnames[] = {
16070 (char *) "self", NULL
16071 };
16072
16073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextForeground",kwnames,&obj0)) goto fail;
16074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16075 if (SWIG_arg_fail(1)) SWIG_fail;
16076 {
16077 PyThreadState* __tstate = wxPyBeginAllowThreads();
16078 {
16079 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextForeground();
16080 result = (wxColour *) &_result_ref;
16081 }
16082
16083 wxPyEndAllowThreads(__tstate);
16084 if (PyErr_Occurred()) SWIG_fail;
16085 }
16086 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
16087 return resultobj;
16088 fail:
16089 return NULL;
16090 }
16091
16092
16093 static PyObject *_wrap_DC_SetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16094 PyObject *resultobj;
16095 wxDC *arg1 = (wxDC *) 0 ;
16096 wxColour *arg2 = 0 ;
16097 wxColour temp2 ;
16098 PyObject * obj0 = 0 ;
16099 PyObject * obj1 = 0 ;
16100 char *kwnames[] = {
16101 (char *) "self",(char *) "colour", NULL
16102 };
16103
16104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextForeground",kwnames,&obj0,&obj1)) goto fail;
16105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16106 if (SWIG_arg_fail(1)) SWIG_fail;
16107 {
16108 arg2 = &temp2;
16109 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16110 }
16111 {
16112 PyThreadState* __tstate = wxPyBeginAllowThreads();
16113 (arg1)->SetTextForeground((wxColour const &)*arg2);
16114
16115 wxPyEndAllowThreads(__tstate);
16116 if (PyErr_Occurred()) SWIG_fail;
16117 }
16118 Py_INCREF(Py_None); resultobj = Py_None;
16119 return resultobj;
16120 fail:
16121 return NULL;
16122 }
16123
16124
16125 static PyObject *_wrap_DC_SetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16126 PyObject *resultobj;
16127 wxDC *arg1 = (wxDC *) 0 ;
16128 wxColour *arg2 = 0 ;
16129 wxColour temp2 ;
16130 PyObject * obj0 = 0 ;
16131 PyObject * obj1 = 0 ;
16132 char *kwnames[] = {
16133 (char *) "self",(char *) "colour", NULL
16134 };
16135
16136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextBackground",kwnames,&obj0,&obj1)) goto fail;
16137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16138 if (SWIG_arg_fail(1)) SWIG_fail;
16139 {
16140 arg2 = &temp2;
16141 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16142 }
16143 {
16144 PyThreadState* __tstate = wxPyBeginAllowThreads();
16145 (arg1)->SetTextBackground((wxColour const &)*arg2);
16146
16147 wxPyEndAllowThreads(__tstate);
16148 if (PyErr_Occurred()) SWIG_fail;
16149 }
16150 Py_INCREF(Py_None); resultobj = Py_None;
16151 return resultobj;
16152 fail:
16153 return NULL;
16154 }
16155
16156
16157 static PyObject *_wrap_DC_GetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16158 PyObject *resultobj;
16159 wxDC *arg1 = (wxDC *) 0 ;
16160 int result;
16161 PyObject * obj0 = 0 ;
16162 char *kwnames[] = {
16163 (char *) "self", NULL
16164 };
16165
16166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetMapMode",kwnames,&obj0)) goto fail;
16167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16168 if (SWIG_arg_fail(1)) SWIG_fail;
16169 {
16170 PyThreadState* __tstate = wxPyBeginAllowThreads();
16171 result = (int)((wxDC const *)arg1)->GetMapMode();
16172
16173 wxPyEndAllowThreads(__tstate);
16174 if (PyErr_Occurred()) SWIG_fail;
16175 }
16176 {
16177 resultobj = SWIG_From_int((int)(result));
16178 }
16179 return resultobj;
16180 fail:
16181 return NULL;
16182 }
16183
16184
16185 static PyObject *_wrap_DC_SetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16186 PyObject *resultobj;
16187 wxDC *arg1 = (wxDC *) 0 ;
16188 int arg2 ;
16189 PyObject * obj0 = 0 ;
16190 PyObject * obj1 = 0 ;
16191 char *kwnames[] = {
16192 (char *) "self",(char *) "mode", NULL
16193 };
16194
16195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetMapMode",kwnames,&obj0,&obj1)) goto fail;
16196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16197 if (SWIG_arg_fail(1)) SWIG_fail;
16198 {
16199 arg2 = (int)(SWIG_As_int(obj1));
16200 if (SWIG_arg_fail(2)) SWIG_fail;
16201 }
16202 {
16203 PyThreadState* __tstate = wxPyBeginAllowThreads();
16204 (arg1)->SetMapMode(arg2);
16205
16206 wxPyEndAllowThreads(__tstate);
16207 if (PyErr_Occurred()) SWIG_fail;
16208 }
16209 Py_INCREF(Py_None); resultobj = Py_None;
16210 return resultobj;
16211 fail:
16212 return NULL;
16213 }
16214
16215
16216 static PyObject *_wrap_DC_GetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16217 PyObject *resultobj;
16218 wxDC *arg1 = (wxDC *) 0 ;
16219 double *arg2 = (double *) 0 ;
16220 double *arg3 = (double *) 0 ;
16221 double temp2 ;
16222 int res2 = 0 ;
16223 double temp3 ;
16224 int res3 = 0 ;
16225 PyObject * obj0 = 0 ;
16226 char *kwnames[] = {
16227 (char *) "self", NULL
16228 };
16229
16230 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16231 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetUserScale",kwnames,&obj0)) goto fail;
16233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16234 if (SWIG_arg_fail(1)) SWIG_fail;
16235 {
16236 PyThreadState* __tstate = wxPyBeginAllowThreads();
16237 ((wxDC const *)arg1)->GetUserScale(arg2,arg3);
16238
16239 wxPyEndAllowThreads(__tstate);
16240 if (PyErr_Occurred()) SWIG_fail;
16241 }
16242 Py_INCREF(Py_None); resultobj = Py_None;
16243 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16244 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16245 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16246 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16247 return resultobj;
16248 fail:
16249 return NULL;
16250 }
16251
16252
16253 static PyObject *_wrap_DC_SetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16254 PyObject *resultobj;
16255 wxDC *arg1 = (wxDC *) 0 ;
16256 double arg2 ;
16257 double arg3 ;
16258 PyObject * obj0 = 0 ;
16259 PyObject * obj1 = 0 ;
16260 PyObject * obj2 = 0 ;
16261 char *kwnames[] = {
16262 (char *) "self",(char *) "x",(char *) "y", NULL
16263 };
16264
16265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetUserScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16267 if (SWIG_arg_fail(1)) SWIG_fail;
16268 {
16269 arg2 = (double)(SWIG_As_double(obj1));
16270 if (SWIG_arg_fail(2)) SWIG_fail;
16271 }
16272 {
16273 arg3 = (double)(SWIG_As_double(obj2));
16274 if (SWIG_arg_fail(3)) SWIG_fail;
16275 }
16276 {
16277 PyThreadState* __tstate = wxPyBeginAllowThreads();
16278 (arg1)->SetUserScale(arg2,arg3);
16279
16280 wxPyEndAllowThreads(__tstate);
16281 if (PyErr_Occurred()) SWIG_fail;
16282 }
16283 Py_INCREF(Py_None); resultobj = Py_None;
16284 return resultobj;
16285 fail:
16286 return NULL;
16287 }
16288
16289
16290 static PyObject *_wrap_DC_GetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16291 PyObject *resultobj;
16292 wxDC *arg1 = (wxDC *) 0 ;
16293 double *arg2 = (double *) 0 ;
16294 double *arg3 = (double *) 0 ;
16295 double temp2 ;
16296 int res2 = 0 ;
16297 double temp3 ;
16298 int res3 = 0 ;
16299 PyObject * obj0 = 0 ;
16300 char *kwnames[] = {
16301 (char *) "self", NULL
16302 };
16303
16304 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16305 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalScale",kwnames,&obj0)) goto fail;
16307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16308 if (SWIG_arg_fail(1)) SWIG_fail;
16309 {
16310 PyThreadState* __tstate = wxPyBeginAllowThreads();
16311 (arg1)->GetLogicalScale(arg2,arg3);
16312
16313 wxPyEndAllowThreads(__tstate);
16314 if (PyErr_Occurred()) SWIG_fail;
16315 }
16316 Py_INCREF(Py_None); resultobj = Py_None;
16317 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16318 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16319 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16320 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16321 return resultobj;
16322 fail:
16323 return NULL;
16324 }
16325
16326
16327 static PyObject *_wrap_DC_SetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16328 PyObject *resultobj;
16329 wxDC *arg1 = (wxDC *) 0 ;
16330 double arg2 ;
16331 double arg3 ;
16332 PyObject * obj0 = 0 ;
16333 PyObject * obj1 = 0 ;
16334 PyObject * obj2 = 0 ;
16335 char *kwnames[] = {
16336 (char *) "self",(char *) "x",(char *) "y", NULL
16337 };
16338
16339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16341 if (SWIG_arg_fail(1)) SWIG_fail;
16342 {
16343 arg2 = (double)(SWIG_As_double(obj1));
16344 if (SWIG_arg_fail(2)) SWIG_fail;
16345 }
16346 {
16347 arg3 = (double)(SWIG_As_double(obj2));
16348 if (SWIG_arg_fail(3)) SWIG_fail;
16349 }
16350 {
16351 PyThreadState* __tstate = wxPyBeginAllowThreads();
16352 (arg1)->SetLogicalScale(arg2,arg3);
16353
16354 wxPyEndAllowThreads(__tstate);
16355 if (PyErr_Occurred()) SWIG_fail;
16356 }
16357 Py_INCREF(Py_None); resultobj = Py_None;
16358 return resultobj;
16359 fail:
16360 return NULL;
16361 }
16362
16363
16364 static PyObject *_wrap_DC_GetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16365 PyObject *resultobj;
16366 wxDC *arg1 = (wxDC *) 0 ;
16367 wxPoint result;
16368 PyObject * obj0 = 0 ;
16369 char *kwnames[] = {
16370 (char *) "self", NULL
16371 };
16372
16373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOrigin",kwnames,&obj0)) goto fail;
16374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16375 if (SWIG_arg_fail(1)) SWIG_fail;
16376 {
16377 PyThreadState* __tstate = wxPyBeginAllowThreads();
16378 result = ((wxDC const *)arg1)->GetLogicalOrigin();
16379
16380 wxPyEndAllowThreads(__tstate);
16381 if (PyErr_Occurred()) SWIG_fail;
16382 }
16383 {
16384 wxPoint * resultptr;
16385 resultptr = new wxPoint((wxPoint &)(result));
16386 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16387 }
16388 return resultobj;
16389 fail:
16390 return NULL;
16391 }
16392
16393
16394 static PyObject *_wrap_DC_GetLogicalOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16395 PyObject *resultobj;
16396 wxDC *arg1 = (wxDC *) 0 ;
16397 int *arg2 = (int *) 0 ;
16398 int *arg3 = (int *) 0 ;
16399 int temp2 ;
16400 int res2 = 0 ;
16401 int temp3 ;
16402 int res3 = 0 ;
16403 PyObject * obj0 = 0 ;
16404 char *kwnames[] = {
16405 (char *) "self", NULL
16406 };
16407
16408 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16409 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOriginTuple",kwnames,&obj0)) goto fail;
16411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16412 if (SWIG_arg_fail(1)) SWIG_fail;
16413 {
16414 PyThreadState* __tstate = wxPyBeginAllowThreads();
16415 ((wxDC const *)arg1)->GetLogicalOrigin(arg2,arg3);
16416
16417 wxPyEndAllowThreads(__tstate);
16418 if (PyErr_Occurred()) SWIG_fail;
16419 }
16420 Py_INCREF(Py_None); resultobj = Py_None;
16421 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16422 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16423 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16424 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16425 return resultobj;
16426 fail:
16427 return NULL;
16428 }
16429
16430
16431 static PyObject *_wrap_DC_SetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16432 PyObject *resultobj;
16433 wxDC *arg1 = (wxDC *) 0 ;
16434 int arg2 ;
16435 int arg3 ;
16436 PyObject * obj0 = 0 ;
16437 PyObject * obj1 = 0 ;
16438 PyObject * obj2 = 0 ;
16439 char *kwnames[] = {
16440 (char *) "self",(char *) "x",(char *) "y", NULL
16441 };
16442
16443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
16444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16445 if (SWIG_arg_fail(1)) SWIG_fail;
16446 {
16447 arg2 = (int)(SWIG_As_int(obj1));
16448 if (SWIG_arg_fail(2)) SWIG_fail;
16449 }
16450 {
16451 arg3 = (int)(SWIG_As_int(obj2));
16452 if (SWIG_arg_fail(3)) SWIG_fail;
16453 }
16454 {
16455 PyThreadState* __tstate = wxPyBeginAllowThreads();
16456 (arg1)->SetLogicalOrigin(arg2,arg3);
16457
16458 wxPyEndAllowThreads(__tstate);
16459 if (PyErr_Occurred()) SWIG_fail;
16460 }
16461 Py_INCREF(Py_None); resultobj = Py_None;
16462 return resultobj;
16463 fail:
16464 return NULL;
16465 }
16466
16467
16468 static PyObject *_wrap_DC_SetLogicalOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16469 PyObject *resultobj;
16470 wxDC *arg1 = (wxDC *) 0 ;
16471 wxPoint *arg2 = 0 ;
16472 wxPoint temp2 ;
16473 PyObject * obj0 = 0 ;
16474 PyObject * obj1 = 0 ;
16475 char *kwnames[] = {
16476 (char *) "self",(char *) "point", NULL
16477 };
16478
16479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalOriginPoint",kwnames,&obj0,&obj1)) goto fail;
16480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16481 if (SWIG_arg_fail(1)) SWIG_fail;
16482 {
16483 arg2 = &temp2;
16484 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16485 }
16486 {
16487 PyThreadState* __tstate = wxPyBeginAllowThreads();
16488 wxDC_SetLogicalOriginPoint(arg1,(wxPoint const &)*arg2);
16489
16490 wxPyEndAllowThreads(__tstate);
16491 if (PyErr_Occurred()) SWIG_fail;
16492 }
16493 Py_INCREF(Py_None); resultobj = Py_None;
16494 return resultobj;
16495 fail:
16496 return NULL;
16497 }
16498
16499
16500 static PyObject *_wrap_DC_GetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16501 PyObject *resultobj;
16502 wxDC *arg1 = (wxDC *) 0 ;
16503 wxPoint result;
16504 PyObject * obj0 = 0 ;
16505 char *kwnames[] = {
16506 (char *) "self", NULL
16507 };
16508
16509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOrigin",kwnames,&obj0)) goto fail;
16510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16511 if (SWIG_arg_fail(1)) SWIG_fail;
16512 {
16513 PyThreadState* __tstate = wxPyBeginAllowThreads();
16514 result = ((wxDC const *)arg1)->GetDeviceOrigin();
16515
16516 wxPyEndAllowThreads(__tstate);
16517 if (PyErr_Occurred()) SWIG_fail;
16518 }
16519 {
16520 wxPoint * resultptr;
16521 resultptr = new wxPoint((wxPoint &)(result));
16522 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16523 }
16524 return resultobj;
16525 fail:
16526 return NULL;
16527 }
16528
16529
16530 static PyObject *_wrap_DC_GetDeviceOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16531 PyObject *resultobj;
16532 wxDC *arg1 = (wxDC *) 0 ;
16533 int *arg2 = (int *) 0 ;
16534 int *arg3 = (int *) 0 ;
16535 int temp2 ;
16536 int res2 = 0 ;
16537 int temp3 ;
16538 int res3 = 0 ;
16539 PyObject * obj0 = 0 ;
16540 char *kwnames[] = {
16541 (char *) "self", NULL
16542 };
16543
16544 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16545 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOriginTuple",kwnames,&obj0)) goto fail;
16547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16548 if (SWIG_arg_fail(1)) SWIG_fail;
16549 {
16550 PyThreadState* __tstate = wxPyBeginAllowThreads();
16551 ((wxDC const *)arg1)->GetDeviceOrigin(arg2,arg3);
16552
16553 wxPyEndAllowThreads(__tstate);
16554 if (PyErr_Occurred()) SWIG_fail;
16555 }
16556 Py_INCREF(Py_None); resultobj = Py_None;
16557 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16558 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16559 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16560 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16561 return resultobj;
16562 fail:
16563 return NULL;
16564 }
16565
16566
16567 static PyObject *_wrap_DC_SetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16568 PyObject *resultobj;
16569 wxDC *arg1 = (wxDC *) 0 ;
16570 int arg2 ;
16571 int arg3 ;
16572 PyObject * obj0 = 0 ;
16573 PyObject * obj1 = 0 ;
16574 PyObject * obj2 = 0 ;
16575 char *kwnames[] = {
16576 (char *) "self",(char *) "x",(char *) "y", NULL
16577 };
16578
16579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetDeviceOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
16580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16581 if (SWIG_arg_fail(1)) SWIG_fail;
16582 {
16583 arg2 = (int)(SWIG_As_int(obj1));
16584 if (SWIG_arg_fail(2)) SWIG_fail;
16585 }
16586 {
16587 arg3 = (int)(SWIG_As_int(obj2));
16588 if (SWIG_arg_fail(3)) SWIG_fail;
16589 }
16590 {
16591 PyThreadState* __tstate = wxPyBeginAllowThreads();
16592 (arg1)->SetDeviceOrigin(arg2,arg3);
16593
16594 wxPyEndAllowThreads(__tstate);
16595 if (PyErr_Occurred()) SWIG_fail;
16596 }
16597 Py_INCREF(Py_None); resultobj = Py_None;
16598 return resultobj;
16599 fail:
16600 return NULL;
16601 }
16602
16603
16604 static PyObject *_wrap_DC_SetDeviceOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16605 PyObject *resultobj;
16606 wxDC *arg1 = (wxDC *) 0 ;
16607 wxPoint *arg2 = 0 ;
16608 wxPoint temp2 ;
16609 PyObject * obj0 = 0 ;
16610 PyObject * obj1 = 0 ;
16611 char *kwnames[] = {
16612 (char *) "self",(char *) "point", NULL
16613 };
16614
16615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetDeviceOriginPoint",kwnames,&obj0,&obj1)) goto fail;
16616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16617 if (SWIG_arg_fail(1)) SWIG_fail;
16618 {
16619 arg2 = &temp2;
16620 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16621 }
16622 {
16623 PyThreadState* __tstate = wxPyBeginAllowThreads();
16624 wxDC_SetDeviceOriginPoint(arg1,(wxPoint const &)*arg2);
16625
16626 wxPyEndAllowThreads(__tstate);
16627 if (PyErr_Occurred()) SWIG_fail;
16628 }
16629 Py_INCREF(Py_None); resultobj = Py_None;
16630 return resultobj;
16631 fail:
16632 return NULL;
16633 }
16634
16635
16636 static PyObject *_wrap_DC_SetAxisOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16637 PyObject *resultobj;
16638 wxDC *arg1 = (wxDC *) 0 ;
16639 bool arg2 ;
16640 bool arg3 ;
16641 PyObject * obj0 = 0 ;
16642 PyObject * obj1 = 0 ;
16643 PyObject * obj2 = 0 ;
16644 char *kwnames[] = {
16645 (char *) "self",(char *) "xLeftRight",(char *) "yBottomUp", NULL
16646 };
16647
16648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetAxisOrientation",kwnames,&obj0,&obj1,&obj2)) goto fail;
16649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16650 if (SWIG_arg_fail(1)) SWIG_fail;
16651 {
16652 arg2 = (bool)(SWIG_As_bool(obj1));
16653 if (SWIG_arg_fail(2)) SWIG_fail;
16654 }
16655 {
16656 arg3 = (bool)(SWIG_As_bool(obj2));
16657 if (SWIG_arg_fail(3)) SWIG_fail;
16658 }
16659 {
16660 PyThreadState* __tstate = wxPyBeginAllowThreads();
16661 (arg1)->SetAxisOrientation(arg2,arg3);
16662
16663 wxPyEndAllowThreads(__tstate);
16664 if (PyErr_Occurred()) SWIG_fail;
16665 }
16666 Py_INCREF(Py_None); resultobj = Py_None;
16667 return resultobj;
16668 fail:
16669 return NULL;
16670 }
16671
16672
16673 static PyObject *_wrap_DC_GetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
16674 PyObject *resultobj;
16675 wxDC *arg1 = (wxDC *) 0 ;
16676 int result;
16677 PyObject * obj0 = 0 ;
16678 char *kwnames[] = {
16679 (char *) "self", NULL
16680 };
16681
16682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalFunction",kwnames,&obj0)) goto fail;
16683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16684 if (SWIG_arg_fail(1)) SWIG_fail;
16685 {
16686 PyThreadState* __tstate = wxPyBeginAllowThreads();
16687 result = (int)((wxDC const *)arg1)->GetLogicalFunction();
16688
16689 wxPyEndAllowThreads(__tstate);
16690 if (PyErr_Occurred()) SWIG_fail;
16691 }
16692 {
16693 resultobj = SWIG_From_int((int)(result));
16694 }
16695 return resultobj;
16696 fail:
16697 return NULL;
16698 }
16699
16700
16701 static PyObject *_wrap_DC_SetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
16702 PyObject *resultobj;
16703 wxDC *arg1 = (wxDC *) 0 ;
16704 int arg2 ;
16705 PyObject * obj0 = 0 ;
16706 PyObject * obj1 = 0 ;
16707 char *kwnames[] = {
16708 (char *) "self",(char *) "function", NULL
16709 };
16710
16711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalFunction",kwnames,&obj0,&obj1)) goto fail;
16712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16713 if (SWIG_arg_fail(1)) SWIG_fail;
16714 {
16715 arg2 = (int)(SWIG_As_int(obj1));
16716 if (SWIG_arg_fail(2)) SWIG_fail;
16717 }
16718 {
16719 PyThreadState* __tstate = wxPyBeginAllowThreads();
16720 (arg1)->SetLogicalFunction(arg2);
16721
16722 wxPyEndAllowThreads(__tstate);
16723 if (PyErr_Occurred()) SWIG_fail;
16724 }
16725 Py_INCREF(Py_None); resultobj = Py_None;
16726 return resultobj;
16727 fail:
16728 return NULL;
16729 }
16730
16731
16732 static PyObject *_wrap_DC_ComputeScaleAndOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16733 PyObject *resultobj;
16734 wxDC *arg1 = (wxDC *) 0 ;
16735 PyObject * obj0 = 0 ;
16736 char *kwnames[] = {
16737 (char *) "self", NULL
16738 };
16739
16740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ComputeScaleAndOrigin",kwnames,&obj0)) goto fail;
16741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16742 if (SWIG_arg_fail(1)) SWIG_fail;
16743 {
16744 PyThreadState* __tstate = wxPyBeginAllowThreads();
16745 (arg1)->ComputeScaleAndOrigin();
16746
16747 wxPyEndAllowThreads(__tstate);
16748 if (PyErr_Occurred()) SWIG_fail;
16749 }
16750 Py_INCREF(Py_None); resultobj = Py_None;
16751 return resultobj;
16752 fail:
16753 return NULL;
16754 }
16755
16756
16757 static PyObject *_wrap_DC_CalcBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16758 PyObject *resultobj;
16759 wxDC *arg1 = (wxDC *) 0 ;
16760 int arg2 ;
16761 int arg3 ;
16762 PyObject * obj0 = 0 ;
16763 PyObject * obj1 = 0 ;
16764 PyObject * obj2 = 0 ;
16765 char *kwnames[] = {
16766 (char *) "self",(char *) "x",(char *) "y", NULL
16767 };
16768
16769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CalcBoundingBox",kwnames,&obj0,&obj1,&obj2)) goto fail;
16770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16771 if (SWIG_arg_fail(1)) SWIG_fail;
16772 {
16773 arg2 = (int)(SWIG_As_int(obj1));
16774 if (SWIG_arg_fail(2)) SWIG_fail;
16775 }
16776 {
16777 arg3 = (int)(SWIG_As_int(obj2));
16778 if (SWIG_arg_fail(3)) SWIG_fail;
16779 }
16780 {
16781 PyThreadState* __tstate = wxPyBeginAllowThreads();
16782 (arg1)->CalcBoundingBox(arg2,arg3);
16783
16784 wxPyEndAllowThreads(__tstate);
16785 if (PyErr_Occurred()) SWIG_fail;
16786 }
16787 Py_INCREF(Py_None); resultobj = Py_None;
16788 return resultobj;
16789 fail:
16790 return NULL;
16791 }
16792
16793
16794 static PyObject *_wrap_DC_CalcBoundingBoxPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16795 PyObject *resultobj;
16796 wxDC *arg1 = (wxDC *) 0 ;
16797 wxPoint *arg2 = 0 ;
16798 wxPoint temp2 ;
16799 PyObject * obj0 = 0 ;
16800 PyObject * obj1 = 0 ;
16801 char *kwnames[] = {
16802 (char *) "self",(char *) "point", NULL
16803 };
16804
16805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CalcBoundingBoxPoint",kwnames,&obj0,&obj1)) goto fail;
16806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16807 if (SWIG_arg_fail(1)) SWIG_fail;
16808 {
16809 arg2 = &temp2;
16810 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16811 }
16812 {
16813 PyThreadState* __tstate = wxPyBeginAllowThreads();
16814 wxDC_CalcBoundingBoxPoint(arg1,(wxPoint const &)*arg2);
16815
16816 wxPyEndAllowThreads(__tstate);
16817 if (PyErr_Occurred()) SWIG_fail;
16818 }
16819 Py_INCREF(Py_None); resultobj = Py_None;
16820 return resultobj;
16821 fail:
16822 return NULL;
16823 }
16824
16825
16826 static PyObject *_wrap_DC_ResetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16827 PyObject *resultobj;
16828 wxDC *arg1 = (wxDC *) 0 ;
16829 PyObject * obj0 = 0 ;
16830 char *kwnames[] = {
16831 (char *) "self", NULL
16832 };
16833
16834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ResetBoundingBox",kwnames,&obj0)) goto fail;
16835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16836 if (SWIG_arg_fail(1)) SWIG_fail;
16837 {
16838 PyThreadState* __tstate = wxPyBeginAllowThreads();
16839 (arg1)->ResetBoundingBox();
16840
16841 wxPyEndAllowThreads(__tstate);
16842 if (PyErr_Occurred()) SWIG_fail;
16843 }
16844 Py_INCREF(Py_None); resultobj = Py_None;
16845 return resultobj;
16846 fail:
16847 return NULL;
16848 }
16849
16850
16851 static PyObject *_wrap_DC_MinX(PyObject *, PyObject *args, PyObject *kwargs) {
16852 PyObject *resultobj;
16853 wxDC *arg1 = (wxDC *) 0 ;
16854 int result;
16855 PyObject * obj0 = 0 ;
16856 char *kwnames[] = {
16857 (char *) "self", NULL
16858 };
16859
16860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinX",kwnames,&obj0)) goto fail;
16861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16862 if (SWIG_arg_fail(1)) SWIG_fail;
16863 {
16864 PyThreadState* __tstate = wxPyBeginAllowThreads();
16865 result = (int)((wxDC const *)arg1)->MinX();
16866
16867 wxPyEndAllowThreads(__tstate);
16868 if (PyErr_Occurred()) SWIG_fail;
16869 }
16870 {
16871 resultobj = SWIG_From_int((int)(result));
16872 }
16873 return resultobj;
16874 fail:
16875 return NULL;
16876 }
16877
16878
16879 static PyObject *_wrap_DC_MaxX(PyObject *, PyObject *args, PyObject *kwargs) {
16880 PyObject *resultobj;
16881 wxDC *arg1 = (wxDC *) 0 ;
16882 int result;
16883 PyObject * obj0 = 0 ;
16884 char *kwnames[] = {
16885 (char *) "self", NULL
16886 };
16887
16888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxX",kwnames,&obj0)) goto fail;
16889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16890 if (SWIG_arg_fail(1)) SWIG_fail;
16891 {
16892 PyThreadState* __tstate = wxPyBeginAllowThreads();
16893 result = (int)((wxDC const *)arg1)->MaxX();
16894
16895 wxPyEndAllowThreads(__tstate);
16896 if (PyErr_Occurred()) SWIG_fail;
16897 }
16898 {
16899 resultobj = SWIG_From_int((int)(result));
16900 }
16901 return resultobj;
16902 fail:
16903 return NULL;
16904 }
16905
16906
16907 static PyObject *_wrap_DC_MinY(PyObject *, PyObject *args, PyObject *kwargs) {
16908 PyObject *resultobj;
16909 wxDC *arg1 = (wxDC *) 0 ;
16910 int result;
16911 PyObject * obj0 = 0 ;
16912 char *kwnames[] = {
16913 (char *) "self", NULL
16914 };
16915
16916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinY",kwnames,&obj0)) goto fail;
16917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16918 if (SWIG_arg_fail(1)) SWIG_fail;
16919 {
16920 PyThreadState* __tstate = wxPyBeginAllowThreads();
16921 result = (int)((wxDC const *)arg1)->MinY();
16922
16923 wxPyEndAllowThreads(__tstate);
16924 if (PyErr_Occurred()) SWIG_fail;
16925 }
16926 {
16927 resultobj = SWIG_From_int((int)(result));
16928 }
16929 return resultobj;
16930 fail:
16931 return NULL;
16932 }
16933
16934
16935 static PyObject *_wrap_DC_MaxY(PyObject *, PyObject *args, PyObject *kwargs) {
16936 PyObject *resultobj;
16937 wxDC *arg1 = (wxDC *) 0 ;
16938 int result;
16939 PyObject * obj0 = 0 ;
16940 char *kwnames[] = {
16941 (char *) "self", NULL
16942 };
16943
16944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxY",kwnames,&obj0)) goto fail;
16945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16946 if (SWIG_arg_fail(1)) SWIG_fail;
16947 {
16948 PyThreadState* __tstate = wxPyBeginAllowThreads();
16949 result = (int)((wxDC const *)arg1)->MaxY();
16950
16951 wxPyEndAllowThreads(__tstate);
16952 if (PyErr_Occurred()) SWIG_fail;
16953 }
16954 {
16955 resultobj = SWIG_From_int((int)(result));
16956 }
16957 return resultobj;
16958 fail:
16959 return NULL;
16960 }
16961
16962
16963 static PyObject *_wrap_DC_GetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16964 PyObject *resultobj;
16965 wxDC *arg1 = (wxDC *) 0 ;
16966 int *arg2 = (int *) 0 ;
16967 int *arg3 = (int *) 0 ;
16968 int *arg4 = (int *) 0 ;
16969 int *arg5 = (int *) 0 ;
16970 int temp2 ;
16971 int res2 = 0 ;
16972 int temp3 ;
16973 int res3 = 0 ;
16974 int temp4 ;
16975 int res4 = 0 ;
16976 int temp5 ;
16977 int res5 = 0 ;
16978 PyObject * obj0 = 0 ;
16979 char *kwnames[] = {
16980 (char *) "self", NULL
16981 };
16982
16983 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16984 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16985 arg4 = &temp4; res4 = SWIG_NEWOBJ;
16986 arg5 = &temp5; res5 = SWIG_NEWOBJ;
16987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBoundingBox",kwnames,&obj0)) goto fail;
16988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16989 if (SWIG_arg_fail(1)) SWIG_fail;
16990 {
16991 PyThreadState* __tstate = wxPyBeginAllowThreads();
16992 wxDC_GetBoundingBox(arg1,arg2,arg3,arg4,arg5);
16993
16994 wxPyEndAllowThreads(__tstate);
16995 if (PyErr_Occurred()) SWIG_fail;
16996 }
16997 Py_INCREF(Py_None); resultobj = Py_None;
16998 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16999 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
17000 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17001 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
17002 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
17003 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
17004 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
17005 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
17006 return resultobj;
17007 fail:
17008 return NULL;
17009 }
17010
17011
17012 static PyObject *_wrap_DC__DrawPointList(PyObject *, PyObject *args, PyObject *kwargs) {
17013 PyObject *resultobj;
17014 wxDC *arg1 = (wxDC *) 0 ;
17015 PyObject *arg2 = (PyObject *) 0 ;
17016 PyObject *arg3 = (PyObject *) 0 ;
17017 PyObject *arg4 = (PyObject *) 0 ;
17018 PyObject *result;
17019 PyObject * obj0 = 0 ;
17020 PyObject * obj1 = 0 ;
17021 PyObject * obj2 = 0 ;
17022 PyObject * obj3 = 0 ;
17023 char *kwnames[] = {
17024 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17025 };
17026
17027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPointList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17029 if (SWIG_arg_fail(1)) SWIG_fail;
17030 arg2 = obj1;
17031 arg3 = obj2;
17032 arg4 = obj3;
17033 {
17034 PyThreadState* __tstate = wxPyBeginAllowThreads();
17035 result = (PyObject *)wxDC__DrawPointList(arg1,arg2,arg3,arg4);
17036
17037 wxPyEndAllowThreads(__tstate);
17038 if (PyErr_Occurred()) SWIG_fail;
17039 }
17040 resultobj = result;
17041 return resultobj;
17042 fail:
17043 return NULL;
17044 }
17045
17046
17047 static PyObject *_wrap_DC__DrawLineList(PyObject *, PyObject *args, PyObject *kwargs) {
17048 PyObject *resultobj;
17049 wxDC *arg1 = (wxDC *) 0 ;
17050 PyObject *arg2 = (PyObject *) 0 ;
17051 PyObject *arg3 = (PyObject *) 0 ;
17052 PyObject *arg4 = (PyObject *) 0 ;
17053 PyObject *result;
17054 PyObject * obj0 = 0 ;
17055 PyObject * obj1 = 0 ;
17056 PyObject * obj2 = 0 ;
17057 PyObject * obj3 = 0 ;
17058 char *kwnames[] = {
17059 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17060 };
17061
17062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawLineList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17064 if (SWIG_arg_fail(1)) SWIG_fail;
17065 arg2 = obj1;
17066 arg3 = obj2;
17067 arg4 = obj3;
17068 {
17069 PyThreadState* __tstate = wxPyBeginAllowThreads();
17070 result = (PyObject *)wxDC__DrawLineList(arg1,arg2,arg3,arg4);
17071
17072 wxPyEndAllowThreads(__tstate);
17073 if (PyErr_Occurred()) SWIG_fail;
17074 }
17075 resultobj = result;
17076 return resultobj;
17077 fail:
17078 return NULL;
17079 }
17080
17081
17082 static PyObject *_wrap_DC__DrawRectangleList(PyObject *, PyObject *args, PyObject *kwargs) {
17083 PyObject *resultobj;
17084 wxDC *arg1 = (wxDC *) 0 ;
17085 PyObject *arg2 = (PyObject *) 0 ;
17086 PyObject *arg3 = (PyObject *) 0 ;
17087 PyObject *arg4 = (PyObject *) 0 ;
17088 PyObject *result;
17089 PyObject * obj0 = 0 ;
17090 PyObject * obj1 = 0 ;
17091 PyObject * obj2 = 0 ;
17092 PyObject * obj3 = 0 ;
17093 char *kwnames[] = {
17094 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17095 };
17096
17097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawRectangleList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17099 if (SWIG_arg_fail(1)) SWIG_fail;
17100 arg2 = obj1;
17101 arg3 = obj2;
17102 arg4 = obj3;
17103 {
17104 PyThreadState* __tstate = wxPyBeginAllowThreads();
17105 result = (PyObject *)wxDC__DrawRectangleList(arg1,arg2,arg3,arg4);
17106
17107 wxPyEndAllowThreads(__tstate);
17108 if (PyErr_Occurred()) SWIG_fail;
17109 }
17110 resultobj = result;
17111 return resultobj;
17112 fail:
17113 return NULL;
17114 }
17115
17116
17117 static PyObject *_wrap_DC__DrawEllipseList(PyObject *, PyObject *args, PyObject *kwargs) {
17118 PyObject *resultobj;
17119 wxDC *arg1 = (wxDC *) 0 ;
17120 PyObject *arg2 = (PyObject *) 0 ;
17121 PyObject *arg3 = (PyObject *) 0 ;
17122 PyObject *arg4 = (PyObject *) 0 ;
17123 PyObject *result;
17124 PyObject * obj0 = 0 ;
17125 PyObject * obj1 = 0 ;
17126 PyObject * obj2 = 0 ;
17127 PyObject * obj3 = 0 ;
17128 char *kwnames[] = {
17129 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17130 };
17131
17132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawEllipseList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17134 if (SWIG_arg_fail(1)) SWIG_fail;
17135 arg2 = obj1;
17136 arg3 = obj2;
17137 arg4 = obj3;
17138 {
17139 PyThreadState* __tstate = wxPyBeginAllowThreads();
17140 result = (PyObject *)wxDC__DrawEllipseList(arg1,arg2,arg3,arg4);
17141
17142 wxPyEndAllowThreads(__tstate);
17143 if (PyErr_Occurred()) SWIG_fail;
17144 }
17145 resultobj = result;
17146 return resultobj;
17147 fail:
17148 return NULL;
17149 }
17150
17151
17152 static PyObject *_wrap_DC__DrawPolygonList(PyObject *, PyObject *args, PyObject *kwargs) {
17153 PyObject *resultobj;
17154 wxDC *arg1 = (wxDC *) 0 ;
17155 PyObject *arg2 = (PyObject *) 0 ;
17156 PyObject *arg3 = (PyObject *) 0 ;
17157 PyObject *arg4 = (PyObject *) 0 ;
17158 PyObject *result;
17159 PyObject * obj0 = 0 ;
17160 PyObject * obj1 = 0 ;
17161 PyObject * obj2 = 0 ;
17162 PyObject * obj3 = 0 ;
17163 char *kwnames[] = {
17164 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17165 };
17166
17167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPolygonList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17169 if (SWIG_arg_fail(1)) SWIG_fail;
17170 arg2 = obj1;
17171 arg3 = obj2;
17172 arg4 = obj3;
17173 {
17174 PyThreadState* __tstate = wxPyBeginAllowThreads();
17175 result = (PyObject *)wxDC__DrawPolygonList(arg1,arg2,arg3,arg4);
17176
17177 wxPyEndAllowThreads(__tstate);
17178 if (PyErr_Occurred()) SWIG_fail;
17179 }
17180 resultobj = result;
17181 return resultobj;
17182 fail:
17183 return NULL;
17184 }
17185
17186
17187 static PyObject *_wrap_DC__DrawTextList(PyObject *, PyObject *args, PyObject *kwargs) {
17188 PyObject *resultobj;
17189 wxDC *arg1 = (wxDC *) 0 ;
17190 PyObject *arg2 = (PyObject *) 0 ;
17191 PyObject *arg3 = (PyObject *) 0 ;
17192 PyObject *arg4 = (PyObject *) 0 ;
17193 PyObject *arg5 = (PyObject *) 0 ;
17194 PyObject *result;
17195 PyObject * obj0 = 0 ;
17196 PyObject * obj1 = 0 ;
17197 PyObject * obj2 = 0 ;
17198 PyObject * obj3 = 0 ;
17199 PyObject * obj4 = 0 ;
17200 char *kwnames[] = {
17201 (char *) "self",(char *) "textList",(char *) "pyPoints",(char *) "foregroundList",(char *) "backgroundList", NULL
17202 };
17203
17204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC__DrawTextList",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
17205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17206 if (SWIG_arg_fail(1)) SWIG_fail;
17207 arg2 = obj1;
17208 arg3 = obj2;
17209 arg4 = obj3;
17210 arg5 = obj4;
17211 {
17212 PyThreadState* __tstate = wxPyBeginAllowThreads();
17213 result = (PyObject *)wxDC__DrawTextList(arg1,arg2,arg3,arg4,arg5);
17214
17215 wxPyEndAllowThreads(__tstate);
17216 if (PyErr_Occurred()) SWIG_fail;
17217 }
17218 resultobj = result;
17219 return resultobj;
17220 fail:
17221 return NULL;
17222 }
17223
17224
17225 static PyObject * DC_swigregister(PyObject *, PyObject *args) {
17226 PyObject *obj;
17227 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17228 SWIG_TypeClientData(SWIGTYPE_p_wxDC, obj);
17229 Py_INCREF(obj);
17230 return Py_BuildValue((char *)"");
17231 }
17232 static PyObject *_wrap_new_MemoryDC(PyObject *, PyObject *args, PyObject *kwargs) {
17233 PyObject *resultobj;
17234 wxMemoryDC *result;
17235 char *kwnames[] = {
17236 NULL
17237 };
17238
17239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryDC",kwnames)) goto fail;
17240 {
17241 if (!wxPyCheckForApp()) SWIG_fail;
17242 PyThreadState* __tstate = wxPyBeginAllowThreads();
17243 result = (wxMemoryDC *)new wxMemoryDC();
17244
17245 wxPyEndAllowThreads(__tstate);
17246 if (PyErr_Occurred()) SWIG_fail;
17247 }
17248 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17249 return resultobj;
17250 fail:
17251 return NULL;
17252 }
17253
17254
17255 static PyObject *_wrap_new_MemoryDCFromDC(PyObject *, PyObject *args, PyObject *kwargs) {
17256 PyObject *resultobj;
17257 wxDC *arg1 = (wxDC *) 0 ;
17258 wxMemoryDC *result;
17259 PyObject * obj0 = 0 ;
17260 char *kwnames[] = {
17261 (char *) "oldDC", NULL
17262 };
17263
17264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_MemoryDCFromDC",kwnames,&obj0)) 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 if (!wxPyCheckForApp()) SWIG_fail;
17269 PyThreadState* __tstate = wxPyBeginAllowThreads();
17270 result = (wxMemoryDC *)new wxMemoryDC(arg1);
17271
17272 wxPyEndAllowThreads(__tstate);
17273 if (PyErr_Occurred()) SWIG_fail;
17274 }
17275 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17276 return resultobj;
17277 fail:
17278 return NULL;
17279 }
17280
17281
17282 static PyObject *_wrap_MemoryDC_SelectObject(PyObject *, PyObject *args, PyObject *kwargs) {
17283 PyObject *resultobj;
17284 wxMemoryDC *arg1 = (wxMemoryDC *) 0 ;
17285 wxBitmap *arg2 = 0 ;
17286 PyObject * obj0 = 0 ;
17287 PyObject * obj1 = 0 ;
17288 char *kwnames[] = {
17289 (char *) "self",(char *) "bitmap", NULL
17290 };
17291
17292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryDC_SelectObject",kwnames,&obj0,&obj1)) goto fail;
17293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_EXCEPTION | 0);
17294 if (SWIG_arg_fail(1)) SWIG_fail;
17295 {
17296 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17297 if (SWIG_arg_fail(2)) SWIG_fail;
17298 if (arg2 == NULL) {
17299 SWIG_null_ref("wxBitmap");
17300 }
17301 if (SWIG_arg_fail(2)) SWIG_fail;
17302 }
17303 {
17304 PyThreadState* __tstate = wxPyBeginAllowThreads();
17305 (arg1)->SelectObject((wxBitmap const &)*arg2);
17306
17307 wxPyEndAllowThreads(__tstate);
17308 if (PyErr_Occurred()) SWIG_fail;
17309 }
17310 Py_INCREF(Py_None); resultobj = Py_None;
17311 return resultobj;
17312 fail:
17313 return NULL;
17314 }
17315
17316
17317 static PyObject * MemoryDC_swigregister(PyObject *, PyObject *args) {
17318 PyObject *obj;
17319 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17320 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryDC, obj);
17321 Py_INCREF(obj);
17322 return Py_BuildValue((char *)"");
17323 }
17324 static PyObject *_wrap_new_BufferedDC__SWIG_0(PyObject *, PyObject *args) {
17325 PyObject *resultobj;
17326 wxDC *arg1 = (wxDC *) 0 ;
17327 wxBitmap const &arg2_defvalue = wxNullBitmap ;
17328 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
17329 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17330 wxBufferedDC *result;
17331 PyObject * obj0 = 0 ;
17332 PyObject * obj1 = 0 ;
17333 PyObject * obj2 = 0 ;
17334
17335 if(!PyArg_ParseTuple(args,(char *)"O|OO:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
17336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17337 if (SWIG_arg_fail(1)) SWIG_fail;
17338 if (obj1) {
17339 {
17340 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17341 if (SWIG_arg_fail(2)) SWIG_fail;
17342 if (arg2 == NULL) {
17343 SWIG_null_ref("wxBitmap");
17344 }
17345 if (SWIG_arg_fail(2)) SWIG_fail;
17346 }
17347 }
17348 if (obj2) {
17349 {
17350 arg3 = (int)(SWIG_As_int(obj2));
17351 if (SWIG_arg_fail(3)) SWIG_fail;
17352 }
17353 }
17354 {
17355 if (!wxPyCheckForApp()) SWIG_fail;
17356 PyThreadState* __tstate = wxPyBeginAllowThreads();
17357 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxBitmap const &)*arg2,arg3);
17358
17359 wxPyEndAllowThreads(__tstate);
17360 if (PyErr_Occurred()) SWIG_fail;
17361 }
17362 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17363 return resultobj;
17364 fail:
17365 return NULL;
17366 }
17367
17368
17369 static PyObject *_wrap_new_BufferedDC__SWIG_1(PyObject *, PyObject *args) {
17370 PyObject *resultobj;
17371 wxDC *arg1 = (wxDC *) 0 ;
17372 wxSize *arg2 = 0 ;
17373 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17374 wxBufferedDC *result;
17375 wxSize temp2 ;
17376 PyObject * obj0 = 0 ;
17377 PyObject * obj1 = 0 ;
17378 PyObject * obj2 = 0 ;
17379
17380 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
17381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17382 if (SWIG_arg_fail(1)) SWIG_fail;
17383 {
17384 arg2 = &temp2;
17385 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17386 }
17387 if (obj2) {
17388 {
17389 arg3 = (int)(SWIG_As_int(obj2));
17390 if (SWIG_arg_fail(3)) SWIG_fail;
17391 }
17392 }
17393 {
17394 if (!wxPyCheckForApp()) SWIG_fail;
17395 PyThreadState* __tstate = wxPyBeginAllowThreads();
17396 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxSize const &)*arg2,arg3);
17397
17398 wxPyEndAllowThreads(__tstate);
17399 if (PyErr_Occurred()) SWIG_fail;
17400 }
17401 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17402 return resultobj;
17403 fail:
17404 return NULL;
17405 }
17406
17407
17408 static PyObject *_wrap_new_BufferedDC(PyObject *self, PyObject *args) {
17409 int argc;
17410 PyObject *argv[4];
17411 int ii;
17412
17413 argc = PyObject_Length(args);
17414 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
17415 argv[ii] = PyTuple_GetItem(args,ii);
17416 }
17417 if ((argc >= 1) && (argc <= 3)) {
17418 int _v;
17419 {
17420 void *ptr;
17421 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
17422 _v = 0;
17423 PyErr_Clear();
17424 } else {
17425 _v = 1;
17426 }
17427 }
17428 if (_v) {
17429 if (argc <= 1) {
17430 return _wrap_new_BufferedDC__SWIG_0(self,args);
17431 }
17432 {
17433 void *ptr = 0;
17434 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxBitmap, 0) == -1) {
17435 _v = 0;
17436 PyErr_Clear();
17437 } else {
17438 _v = (ptr != 0);
17439 }
17440 }
17441 if (_v) {
17442 if (argc <= 2) {
17443 return _wrap_new_BufferedDC__SWIG_0(self,args);
17444 }
17445 _v = SWIG_Check_int(argv[2]);
17446 if (_v) {
17447 return _wrap_new_BufferedDC__SWIG_0(self,args);
17448 }
17449 }
17450 }
17451 }
17452 if ((argc >= 2) && (argc <= 3)) {
17453 int _v;
17454 {
17455 void *ptr;
17456 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
17457 _v = 0;
17458 PyErr_Clear();
17459 } else {
17460 _v = 1;
17461 }
17462 }
17463 if (_v) {
17464 {
17465 _v = wxPySimple_typecheck(argv[1], wxT("wxSize"), 2);
17466 }
17467 if (_v) {
17468 if (argc <= 2) {
17469 return _wrap_new_BufferedDC__SWIG_1(self,args);
17470 }
17471 _v = SWIG_Check_int(argv[2]);
17472 if (_v) {
17473 return _wrap_new_BufferedDC__SWIG_1(self,args);
17474 }
17475 }
17476 }
17477 }
17478
17479 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_BufferedDC'");
17480 return NULL;
17481 }
17482
17483
17484 static PyObject *_wrap_delete_BufferedDC(PyObject *, PyObject *args, PyObject *kwargs) {
17485 PyObject *resultobj;
17486 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
17487 PyObject * obj0 = 0 ;
17488 char *kwnames[] = {
17489 (char *) "self", NULL
17490 };
17491
17492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BufferedDC",kwnames,&obj0)) goto fail;
17493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
17494 if (SWIG_arg_fail(1)) SWIG_fail;
17495 {
17496 PyThreadState* __tstate = wxPyBeginAllowThreads();
17497 delete arg1;
17498
17499 wxPyEndAllowThreads(__tstate);
17500 if (PyErr_Occurred()) SWIG_fail;
17501 }
17502 Py_INCREF(Py_None); resultobj = Py_None;
17503 return resultobj;
17504 fail:
17505 return NULL;
17506 }
17507
17508
17509 static PyObject *_wrap_BufferedDC_UnMask(PyObject *, PyObject *args, PyObject *kwargs) {
17510 PyObject *resultobj;
17511 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
17512 PyObject * obj0 = 0 ;
17513 char *kwnames[] = {
17514 (char *) "self", NULL
17515 };
17516
17517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BufferedDC_UnMask",kwnames,&obj0)) goto fail;
17518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
17519 if (SWIG_arg_fail(1)) SWIG_fail;
17520 {
17521 PyThreadState* __tstate = wxPyBeginAllowThreads();
17522 (arg1)->UnMask();
17523
17524 wxPyEndAllowThreads(__tstate);
17525 if (PyErr_Occurred()) SWIG_fail;
17526 }
17527 Py_INCREF(Py_None); resultobj = Py_None;
17528 return resultobj;
17529 fail:
17530 return NULL;
17531 }
17532
17533
17534 static PyObject * BufferedDC_swigregister(PyObject *, PyObject *args) {
17535 PyObject *obj;
17536 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17537 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedDC, obj);
17538 Py_INCREF(obj);
17539 return Py_BuildValue((char *)"");
17540 }
17541 static PyObject *_wrap_new_BufferedPaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
17542 PyObject *resultobj;
17543 wxWindow *arg1 = (wxWindow *) 0 ;
17544 wxBitmap const &arg2_defvalue = wxNullBitmap ;
17545 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
17546 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17547 wxBufferedPaintDC *result;
17548 PyObject * obj0 = 0 ;
17549 PyObject * obj1 = 0 ;
17550 PyObject * obj2 = 0 ;
17551 char *kwnames[] = {
17552 (char *) "window",(char *) "buffer",(char *) "style", NULL
17553 };
17554
17555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_BufferedPaintDC",kwnames,&obj0,&obj1,&obj2)) goto fail;
17556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17557 if (SWIG_arg_fail(1)) SWIG_fail;
17558 if (obj1) {
17559 {
17560 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17561 if (SWIG_arg_fail(2)) SWIG_fail;
17562 if (arg2 == NULL) {
17563 SWIG_null_ref("wxBitmap");
17564 }
17565 if (SWIG_arg_fail(2)) SWIG_fail;
17566 }
17567 }
17568 if (obj2) {
17569 {
17570 arg3 = (int)(SWIG_As_int(obj2));
17571 if (SWIG_arg_fail(3)) SWIG_fail;
17572 }
17573 }
17574 {
17575 if (!wxPyCheckForApp()) SWIG_fail;
17576 PyThreadState* __tstate = wxPyBeginAllowThreads();
17577 result = (wxBufferedPaintDC *)new wxBufferedPaintDC(arg1,(wxBitmap const &)*arg2,arg3);
17578
17579 wxPyEndAllowThreads(__tstate);
17580 if (PyErr_Occurred()) SWIG_fail;
17581 }
17582 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedPaintDC, 1);
17583 return resultobj;
17584 fail:
17585 return NULL;
17586 }
17587
17588
17589 static PyObject * BufferedPaintDC_swigregister(PyObject *, PyObject *args) {
17590 PyObject *obj;
17591 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17592 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedPaintDC, obj);
17593 Py_INCREF(obj);
17594 return Py_BuildValue((char *)"");
17595 }
17596 static PyObject *_wrap_new_ScreenDC(PyObject *, PyObject *args, PyObject *kwargs) {
17597 PyObject *resultobj;
17598 wxScreenDC *result;
17599 char *kwnames[] = {
17600 NULL
17601 };
17602
17603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ScreenDC",kwnames)) goto fail;
17604 {
17605 if (!wxPyCheckForApp()) SWIG_fail;
17606 PyThreadState* __tstate = wxPyBeginAllowThreads();
17607 result = (wxScreenDC *)new wxScreenDC();
17608
17609 wxPyEndAllowThreads(__tstate);
17610 if (PyErr_Occurred()) SWIG_fail;
17611 }
17612 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScreenDC, 1);
17613 return resultobj;
17614 fail:
17615 return NULL;
17616 }
17617
17618
17619 static PyObject *_wrap_ScreenDC_StartDrawingOnTopWin(PyObject *, PyObject *args, PyObject *kwargs) {
17620 PyObject *resultobj;
17621 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17622 wxWindow *arg2 = (wxWindow *) 0 ;
17623 bool result;
17624 PyObject * obj0 = 0 ;
17625 PyObject * obj1 = 0 ;
17626 char *kwnames[] = {
17627 (char *) "self",(char *) "window", NULL
17628 };
17629
17630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScreenDC_StartDrawingOnTopWin",kwnames,&obj0,&obj1)) goto fail;
17631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17632 if (SWIG_arg_fail(1)) SWIG_fail;
17633 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17634 if (SWIG_arg_fail(2)) SWIG_fail;
17635 {
17636 PyThreadState* __tstate = wxPyBeginAllowThreads();
17637 result = (bool)(arg1)->StartDrawingOnTop(arg2);
17638
17639 wxPyEndAllowThreads(__tstate);
17640 if (PyErr_Occurred()) SWIG_fail;
17641 }
17642 {
17643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17644 }
17645 return resultobj;
17646 fail:
17647 return NULL;
17648 }
17649
17650
17651 static PyObject *_wrap_ScreenDC_StartDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
17652 PyObject *resultobj;
17653 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17654 wxRect *arg2 = (wxRect *) NULL ;
17655 bool result;
17656 PyObject * obj0 = 0 ;
17657 PyObject * obj1 = 0 ;
17658 char *kwnames[] = {
17659 (char *) "self",(char *) "rect", NULL
17660 };
17661
17662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ScreenDC_StartDrawingOnTop",kwnames,&obj0,&obj1)) goto fail;
17663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17664 if (SWIG_arg_fail(1)) SWIG_fail;
17665 if (obj1) {
17666 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
17667 if (SWIG_arg_fail(2)) SWIG_fail;
17668 }
17669 {
17670 PyThreadState* __tstate = wxPyBeginAllowThreads();
17671 result = (bool)(arg1)->StartDrawingOnTop(arg2);
17672
17673 wxPyEndAllowThreads(__tstate);
17674 if (PyErr_Occurred()) SWIG_fail;
17675 }
17676 {
17677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17678 }
17679 return resultobj;
17680 fail:
17681 return NULL;
17682 }
17683
17684
17685 static PyObject *_wrap_ScreenDC_EndDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
17686 PyObject *resultobj;
17687 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17688 bool result;
17689 PyObject * obj0 = 0 ;
17690 char *kwnames[] = {
17691 (char *) "self", NULL
17692 };
17693
17694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScreenDC_EndDrawingOnTop",kwnames,&obj0)) goto fail;
17695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17696 if (SWIG_arg_fail(1)) SWIG_fail;
17697 {
17698 PyThreadState* __tstate = wxPyBeginAllowThreads();
17699 result = (bool)(arg1)->EndDrawingOnTop();
17700
17701 wxPyEndAllowThreads(__tstate);
17702 if (PyErr_Occurred()) SWIG_fail;
17703 }
17704 {
17705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17706 }
17707 return resultobj;
17708 fail:
17709 return NULL;
17710 }
17711
17712
17713 static PyObject * ScreenDC_swigregister(PyObject *, PyObject *args) {
17714 PyObject *obj;
17715 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17716 SWIG_TypeClientData(SWIGTYPE_p_wxScreenDC, obj);
17717 Py_INCREF(obj);
17718 return Py_BuildValue((char *)"");
17719 }
17720 static PyObject *_wrap_new_ClientDC(PyObject *, PyObject *args, PyObject *kwargs) {
17721 PyObject *resultobj;
17722 wxWindow *arg1 = (wxWindow *) 0 ;
17723 wxClientDC *result;
17724 PyObject * obj0 = 0 ;
17725 char *kwnames[] = {
17726 (char *) "win", NULL
17727 };
17728
17729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ClientDC",kwnames,&obj0)) goto fail;
17730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17731 if (SWIG_arg_fail(1)) SWIG_fail;
17732 {
17733 if (!wxPyCheckForApp()) SWIG_fail;
17734 PyThreadState* __tstate = wxPyBeginAllowThreads();
17735 result = (wxClientDC *)new wxClientDC(arg1);
17736
17737 wxPyEndAllowThreads(__tstate);
17738 if (PyErr_Occurred()) SWIG_fail;
17739 }
17740 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClientDC, 1);
17741 return resultobj;
17742 fail:
17743 return NULL;
17744 }
17745
17746
17747 static PyObject * ClientDC_swigregister(PyObject *, PyObject *args) {
17748 PyObject *obj;
17749 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17750 SWIG_TypeClientData(SWIGTYPE_p_wxClientDC, obj);
17751 Py_INCREF(obj);
17752 return Py_BuildValue((char *)"");
17753 }
17754 static PyObject *_wrap_new_PaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
17755 PyObject *resultobj;
17756 wxWindow *arg1 = (wxWindow *) 0 ;
17757 wxPaintDC *result;
17758 PyObject * obj0 = 0 ;
17759 char *kwnames[] = {
17760 (char *) "win", NULL
17761 };
17762
17763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PaintDC",kwnames,&obj0)) goto fail;
17764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17765 if (SWIG_arg_fail(1)) SWIG_fail;
17766 {
17767 if (!wxPyCheckForApp()) SWIG_fail;
17768 PyThreadState* __tstate = wxPyBeginAllowThreads();
17769 result = (wxPaintDC *)new wxPaintDC(arg1);
17770
17771 wxPyEndAllowThreads(__tstate);
17772 if (PyErr_Occurred()) SWIG_fail;
17773 }
17774 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintDC, 1);
17775 return resultobj;
17776 fail:
17777 return NULL;
17778 }
17779
17780
17781 static PyObject * PaintDC_swigregister(PyObject *, PyObject *args) {
17782 PyObject *obj;
17783 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17784 SWIG_TypeClientData(SWIGTYPE_p_wxPaintDC, obj);
17785 Py_INCREF(obj);
17786 return Py_BuildValue((char *)"");
17787 }
17788 static PyObject *_wrap_new_WindowDC(PyObject *, PyObject *args, PyObject *kwargs) {
17789 PyObject *resultobj;
17790 wxWindow *arg1 = (wxWindow *) 0 ;
17791 wxWindowDC *result;
17792 PyObject * obj0 = 0 ;
17793 char *kwnames[] = {
17794 (char *) "win", NULL
17795 };
17796
17797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_WindowDC",kwnames,&obj0)) goto fail;
17798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17799 if (SWIG_arg_fail(1)) SWIG_fail;
17800 {
17801 if (!wxPyCheckForApp()) SWIG_fail;
17802 PyThreadState* __tstate = wxPyBeginAllowThreads();
17803 result = (wxWindowDC *)new wxWindowDC(arg1);
17804
17805 wxPyEndAllowThreads(__tstate);
17806 if (PyErr_Occurred()) SWIG_fail;
17807 }
17808 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDC, 1);
17809 return resultobj;
17810 fail:
17811 return NULL;
17812 }
17813
17814
17815 static PyObject * WindowDC_swigregister(PyObject *, PyObject *args) {
17816 PyObject *obj;
17817 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17818 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDC, obj);
17819 Py_INCREF(obj);
17820 return Py_BuildValue((char *)"");
17821 }
17822 static PyObject *_wrap_new_MirrorDC(PyObject *, PyObject *args, PyObject *kwargs) {
17823 PyObject *resultobj;
17824 wxDC *arg1 = 0 ;
17825 bool arg2 ;
17826 wxMirrorDC *result;
17827 PyObject * obj0 = 0 ;
17828 PyObject * obj1 = 0 ;
17829 char *kwnames[] = {
17830 (char *) "dc",(char *) "mirror", NULL
17831 };
17832
17833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_MirrorDC",kwnames,&obj0,&obj1)) goto fail;
17834 {
17835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17836 if (SWIG_arg_fail(1)) SWIG_fail;
17837 if (arg1 == NULL) {
17838 SWIG_null_ref("wxDC");
17839 }
17840 if (SWIG_arg_fail(1)) SWIG_fail;
17841 }
17842 {
17843 arg2 = (bool)(SWIG_As_bool(obj1));
17844 if (SWIG_arg_fail(2)) SWIG_fail;
17845 }
17846 {
17847 if (!wxPyCheckForApp()) SWIG_fail;
17848 PyThreadState* __tstate = wxPyBeginAllowThreads();
17849 result = (wxMirrorDC *)new wxMirrorDC(*arg1,arg2);
17850
17851 wxPyEndAllowThreads(__tstate);
17852 if (PyErr_Occurred()) SWIG_fail;
17853 }
17854 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMirrorDC, 1);
17855 return resultobj;
17856 fail:
17857 return NULL;
17858 }
17859
17860
17861 static PyObject * MirrorDC_swigregister(PyObject *, PyObject *args) {
17862 PyObject *obj;
17863 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17864 SWIG_TypeClientData(SWIGTYPE_p_wxMirrorDC, obj);
17865 Py_INCREF(obj);
17866 return Py_BuildValue((char *)"");
17867 }
17868 static PyObject *_wrap_new_PostScriptDC(PyObject *, PyObject *args, PyObject *kwargs) {
17869 PyObject *resultobj;
17870 wxPrintData *arg1 = 0 ;
17871 wxPostScriptDC *result;
17872 PyObject * obj0 = 0 ;
17873 char *kwnames[] = {
17874 (char *) "printData", NULL
17875 };
17876
17877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PostScriptDC",kwnames,&obj0)) goto fail;
17878 {
17879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
17880 if (SWIG_arg_fail(1)) SWIG_fail;
17881 if (arg1 == NULL) {
17882 SWIG_null_ref("wxPrintData");
17883 }
17884 if (SWIG_arg_fail(1)) SWIG_fail;
17885 }
17886 {
17887 if (!wxPyCheckForApp()) SWIG_fail;
17888 PyThreadState* __tstate = wxPyBeginAllowThreads();
17889 result = (wxPostScriptDC *)new wxPostScriptDC((wxPrintData const &)*arg1);
17890
17891 wxPyEndAllowThreads(__tstate);
17892 if (PyErr_Occurred()) SWIG_fail;
17893 }
17894 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPostScriptDC, 1);
17895 return resultobj;
17896 fail:
17897 return NULL;
17898 }
17899
17900
17901 static PyObject *_wrap_PostScriptDC_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
17902 PyObject *resultobj;
17903 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
17904 wxPrintData *result;
17905 PyObject * obj0 = 0 ;
17906 char *kwnames[] = {
17907 (char *) "self", NULL
17908 };
17909
17910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_GetPrintData",kwnames,&obj0)) goto fail;
17911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
17912 if (SWIG_arg_fail(1)) SWIG_fail;
17913 {
17914 PyThreadState* __tstate = wxPyBeginAllowThreads();
17915 {
17916 wxPrintData &_result_ref = (arg1)->GetPrintData();
17917 result = (wxPrintData *) &_result_ref;
17918 }
17919
17920 wxPyEndAllowThreads(__tstate);
17921 if (PyErr_Occurred()) SWIG_fail;
17922 }
17923 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
17924 return resultobj;
17925 fail:
17926 return NULL;
17927 }
17928
17929
17930 static PyObject *_wrap_PostScriptDC_SetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
17931 PyObject *resultobj;
17932 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
17933 wxPrintData *arg2 = 0 ;
17934 PyObject * obj0 = 0 ;
17935 PyObject * obj1 = 0 ;
17936 char *kwnames[] = {
17937 (char *) "self",(char *) "data", NULL
17938 };
17939
17940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostScriptDC_SetPrintData",kwnames,&obj0,&obj1)) goto fail;
17941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
17942 if (SWIG_arg_fail(1)) SWIG_fail;
17943 {
17944 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
17945 if (SWIG_arg_fail(2)) SWIG_fail;
17946 if (arg2 == NULL) {
17947 SWIG_null_ref("wxPrintData");
17948 }
17949 if (SWIG_arg_fail(2)) SWIG_fail;
17950 }
17951 {
17952 PyThreadState* __tstate = wxPyBeginAllowThreads();
17953 (arg1)->SetPrintData((wxPrintData const &)*arg2);
17954
17955 wxPyEndAllowThreads(__tstate);
17956 if (PyErr_Occurred()) SWIG_fail;
17957 }
17958 Py_INCREF(Py_None); resultobj = Py_None;
17959 return resultobj;
17960 fail:
17961 return NULL;
17962 }
17963
17964
17965 static PyObject *_wrap_PostScriptDC_SetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
17966 PyObject *resultobj;
17967 int arg1 ;
17968 PyObject * obj0 = 0 ;
17969 char *kwnames[] = {
17970 (char *) "ppi", NULL
17971 };
17972
17973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_SetResolution",kwnames,&obj0)) goto fail;
17974 {
17975 arg1 = (int)(SWIG_As_int(obj0));
17976 if (SWIG_arg_fail(1)) SWIG_fail;
17977 }
17978 {
17979 PyThreadState* __tstate = wxPyBeginAllowThreads();
17980 wxPostScriptDC::SetResolution(arg1);
17981
17982 wxPyEndAllowThreads(__tstate);
17983 if (PyErr_Occurred()) SWIG_fail;
17984 }
17985 Py_INCREF(Py_None); resultobj = Py_None;
17986 return resultobj;
17987 fail:
17988 return NULL;
17989 }
17990
17991
17992 static PyObject *_wrap_PostScriptDC_GetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
17993 PyObject *resultobj;
17994 int result;
17995 char *kwnames[] = {
17996 NULL
17997 };
17998
17999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PostScriptDC_GetResolution",kwnames)) goto fail;
18000 {
18001 PyThreadState* __tstate = wxPyBeginAllowThreads();
18002 result = (int)wxPostScriptDC::GetResolution();
18003
18004 wxPyEndAllowThreads(__tstate);
18005 if (PyErr_Occurred()) SWIG_fail;
18006 }
18007 {
18008 resultobj = SWIG_From_int((int)(result));
18009 }
18010 return resultobj;
18011 fail:
18012 return NULL;
18013 }
18014
18015
18016 static PyObject * PostScriptDC_swigregister(PyObject *, PyObject *args) {
18017 PyObject *obj;
18018 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18019 SWIG_TypeClientData(SWIGTYPE_p_wxPostScriptDC, obj);
18020 Py_INCREF(obj);
18021 return Py_BuildValue((char *)"");
18022 }
18023 static PyObject *_wrap_new_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
18024 PyObject *resultobj;
18025 wxString const &arg1_defvalue = wxPyEmptyString ;
18026 wxString *arg1 = (wxString *) &arg1_defvalue ;
18027 wxMetaFile *result;
18028 bool temp1 = false ;
18029 PyObject * obj0 = 0 ;
18030 char *kwnames[] = {
18031 (char *) "filename", NULL
18032 };
18033
18034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MetaFile",kwnames,&obj0)) goto fail;
18035 if (obj0) {
18036 {
18037 arg1 = wxString_in_helper(obj0);
18038 if (arg1 == NULL) SWIG_fail;
18039 temp1 = true;
18040 }
18041 }
18042 {
18043 if (!wxPyCheckForApp()) SWIG_fail;
18044 PyThreadState* __tstate = wxPyBeginAllowThreads();
18045 result = (wxMetaFile *)new wxMetaFile((wxString const &)*arg1);
18046
18047 wxPyEndAllowThreads(__tstate);
18048 if (PyErr_Occurred()) SWIG_fail;
18049 }
18050 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 1);
18051 {
18052 if (temp1)
18053 delete arg1;
18054 }
18055 return resultobj;
18056 fail:
18057 {
18058 if (temp1)
18059 delete arg1;
18060 }
18061 return NULL;
18062 }
18063
18064
18065 static PyObject *_wrap_delete_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
18066 PyObject *resultobj;
18067 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18068 PyObject * obj0 = 0 ;
18069 char *kwnames[] = {
18070 (char *) "self", NULL
18071 };
18072
18073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MetaFile",kwnames,&obj0)) goto fail;
18074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18075 if (SWIG_arg_fail(1)) SWIG_fail;
18076 {
18077 PyThreadState* __tstate = wxPyBeginAllowThreads();
18078 delete arg1;
18079
18080 wxPyEndAllowThreads(__tstate);
18081 if (PyErr_Occurred()) SWIG_fail;
18082 }
18083 Py_INCREF(Py_None); resultobj = Py_None;
18084 return resultobj;
18085 fail:
18086 return NULL;
18087 }
18088
18089
18090 static PyObject *_wrap_MetaFile_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
18091 PyObject *resultobj;
18092 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18093 bool result;
18094 PyObject * obj0 = 0 ;
18095 char *kwnames[] = {
18096 (char *) "self", NULL
18097 };
18098
18099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_Ok",kwnames,&obj0)) goto fail;
18100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18101 if (SWIG_arg_fail(1)) SWIG_fail;
18102 {
18103 PyThreadState* __tstate = wxPyBeginAllowThreads();
18104 result = (bool)(arg1)->Ok();
18105
18106 wxPyEndAllowThreads(__tstate);
18107 if (PyErr_Occurred()) SWIG_fail;
18108 }
18109 {
18110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18111 }
18112 return resultobj;
18113 fail:
18114 return NULL;
18115 }
18116
18117
18118 static PyObject *_wrap_MetaFile_SetClipboard(PyObject *, PyObject *args, PyObject *kwargs) {
18119 PyObject *resultobj;
18120 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18121 int arg2 = (int) 0 ;
18122 int arg3 = (int) 0 ;
18123 bool result;
18124 PyObject * obj0 = 0 ;
18125 PyObject * obj1 = 0 ;
18126 PyObject * obj2 = 0 ;
18127 char *kwnames[] = {
18128 (char *) "self",(char *) "width",(char *) "height", NULL
18129 };
18130
18131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MetaFile_SetClipboard",kwnames,&obj0,&obj1,&obj2)) goto fail;
18132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18133 if (SWIG_arg_fail(1)) SWIG_fail;
18134 if (obj1) {
18135 {
18136 arg2 = (int)(SWIG_As_int(obj1));
18137 if (SWIG_arg_fail(2)) SWIG_fail;
18138 }
18139 }
18140 if (obj2) {
18141 {
18142 arg3 = (int)(SWIG_As_int(obj2));
18143 if (SWIG_arg_fail(3)) SWIG_fail;
18144 }
18145 }
18146 {
18147 PyThreadState* __tstate = wxPyBeginAllowThreads();
18148 result = (bool)(arg1)->SetClipboard(arg2,arg3);
18149
18150 wxPyEndAllowThreads(__tstate);
18151 if (PyErr_Occurred()) SWIG_fail;
18152 }
18153 {
18154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18155 }
18156 return resultobj;
18157 fail:
18158 return NULL;
18159 }
18160
18161
18162 static PyObject *_wrap_MetaFile_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18163 PyObject *resultobj;
18164 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18165 wxSize result;
18166 PyObject * obj0 = 0 ;
18167 char *kwnames[] = {
18168 (char *) "self", NULL
18169 };
18170
18171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetSize",kwnames,&obj0)) goto fail;
18172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18173 if (SWIG_arg_fail(1)) SWIG_fail;
18174 {
18175 PyThreadState* __tstate = wxPyBeginAllowThreads();
18176 result = (arg1)->GetSize();
18177
18178 wxPyEndAllowThreads(__tstate);
18179 if (PyErr_Occurred()) SWIG_fail;
18180 }
18181 {
18182 wxSize * resultptr;
18183 resultptr = new wxSize((wxSize &)(result));
18184 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18185 }
18186 return resultobj;
18187 fail:
18188 return NULL;
18189 }
18190
18191
18192 static PyObject *_wrap_MetaFile_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
18193 PyObject *resultobj;
18194 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18195 int result;
18196 PyObject * obj0 = 0 ;
18197 char *kwnames[] = {
18198 (char *) "self", NULL
18199 };
18200
18201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetWidth",kwnames,&obj0)) goto fail;
18202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18203 if (SWIG_arg_fail(1)) SWIG_fail;
18204 {
18205 PyThreadState* __tstate = wxPyBeginAllowThreads();
18206 result = (int)(arg1)->GetWidth();
18207
18208 wxPyEndAllowThreads(__tstate);
18209 if (PyErr_Occurred()) SWIG_fail;
18210 }
18211 {
18212 resultobj = SWIG_From_int((int)(result));
18213 }
18214 return resultobj;
18215 fail:
18216 return NULL;
18217 }
18218
18219
18220 static PyObject *_wrap_MetaFile_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
18221 PyObject *resultobj;
18222 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18223 int result;
18224 PyObject * obj0 = 0 ;
18225 char *kwnames[] = {
18226 (char *) "self", NULL
18227 };
18228
18229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetHeight",kwnames,&obj0)) goto fail;
18230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18231 if (SWIG_arg_fail(1)) SWIG_fail;
18232 {
18233 PyThreadState* __tstate = wxPyBeginAllowThreads();
18234 result = (int)(arg1)->GetHeight();
18235
18236 wxPyEndAllowThreads(__tstate);
18237 if (PyErr_Occurred()) SWIG_fail;
18238 }
18239 {
18240 resultobj = SWIG_From_int((int)(result));
18241 }
18242 return resultobj;
18243 fail:
18244 return NULL;
18245 }
18246
18247
18248 static PyObject * MetaFile_swigregister(PyObject *, PyObject *args) {
18249 PyObject *obj;
18250 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18251 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFile, obj);
18252 Py_INCREF(obj);
18253 return Py_BuildValue((char *)"");
18254 }
18255 static PyObject *_wrap_new_MetaFileDC(PyObject *, PyObject *args, PyObject *kwargs) {
18256 PyObject *resultobj;
18257 wxString const &arg1_defvalue = wxPyEmptyString ;
18258 wxString *arg1 = (wxString *) &arg1_defvalue ;
18259 int arg2 = (int) 0 ;
18260 int arg3 = (int) 0 ;
18261 wxString const &arg4_defvalue = wxPyEmptyString ;
18262 wxString *arg4 = (wxString *) &arg4_defvalue ;
18263 wxMetaFileDC *result;
18264 bool temp1 = false ;
18265 bool temp4 = false ;
18266 PyObject * obj0 = 0 ;
18267 PyObject * obj1 = 0 ;
18268 PyObject * obj2 = 0 ;
18269 PyObject * obj3 = 0 ;
18270 char *kwnames[] = {
18271 (char *) "filename",(char *) "width",(char *) "height",(char *) "description", NULL
18272 };
18273
18274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_MetaFileDC",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18275 if (obj0) {
18276 {
18277 arg1 = wxString_in_helper(obj0);
18278 if (arg1 == NULL) SWIG_fail;
18279 temp1 = true;
18280 }
18281 }
18282 if (obj1) {
18283 {
18284 arg2 = (int)(SWIG_As_int(obj1));
18285 if (SWIG_arg_fail(2)) SWIG_fail;
18286 }
18287 }
18288 if (obj2) {
18289 {
18290 arg3 = (int)(SWIG_As_int(obj2));
18291 if (SWIG_arg_fail(3)) SWIG_fail;
18292 }
18293 }
18294 if (obj3) {
18295 {
18296 arg4 = wxString_in_helper(obj3);
18297 if (arg4 == NULL) SWIG_fail;
18298 temp4 = true;
18299 }
18300 }
18301 {
18302 if (!wxPyCheckForApp()) SWIG_fail;
18303 PyThreadState* __tstate = wxPyBeginAllowThreads();
18304 result = (wxMetaFileDC *)new wxMetaFileDC((wxString const &)*arg1,arg2,arg3,(wxString const &)*arg4);
18305
18306 wxPyEndAllowThreads(__tstate);
18307 if (PyErr_Occurred()) SWIG_fail;
18308 }
18309 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFileDC, 1);
18310 {
18311 if (temp1)
18312 delete arg1;
18313 }
18314 {
18315 if (temp4)
18316 delete arg4;
18317 }
18318 return resultobj;
18319 fail:
18320 {
18321 if (temp1)
18322 delete arg1;
18323 }
18324 {
18325 if (temp4)
18326 delete arg4;
18327 }
18328 return NULL;
18329 }
18330
18331
18332 static PyObject *_wrap_MetaFileDC_Close(PyObject *, PyObject *args, PyObject *kwargs) {
18333 PyObject *resultobj;
18334 wxMetaFileDC *arg1 = (wxMetaFileDC *) 0 ;
18335 wxMetaFile *result;
18336 PyObject * obj0 = 0 ;
18337 char *kwnames[] = {
18338 (char *) "self", NULL
18339 };
18340
18341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFileDC_Close",kwnames,&obj0)) goto fail;
18342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFileDC, SWIG_POINTER_EXCEPTION | 0);
18343 if (SWIG_arg_fail(1)) SWIG_fail;
18344 {
18345 PyThreadState* __tstate = wxPyBeginAllowThreads();
18346 result = (wxMetaFile *)(arg1)->Close();
18347
18348 wxPyEndAllowThreads(__tstate);
18349 if (PyErr_Occurred()) SWIG_fail;
18350 }
18351 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 0);
18352 return resultobj;
18353 fail:
18354 return NULL;
18355 }
18356
18357
18358 static PyObject * MetaFileDC_swigregister(PyObject *, PyObject *args) {
18359 PyObject *obj;
18360 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18361 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFileDC, obj);
18362 Py_INCREF(obj);
18363 return Py_BuildValue((char *)"");
18364 }
18365 static PyObject *_wrap_new_PrinterDC(PyObject *, PyObject *args, PyObject *kwargs) {
18366 PyObject *resultobj;
18367 wxPrintData *arg1 = 0 ;
18368 wxPrinterDC *result;
18369 PyObject * obj0 = 0 ;
18370 char *kwnames[] = {
18371 (char *) "printData", NULL
18372 };
18373
18374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PrinterDC",kwnames,&obj0)) goto fail;
18375 {
18376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18377 if (SWIG_arg_fail(1)) SWIG_fail;
18378 if (arg1 == NULL) {
18379 SWIG_null_ref("wxPrintData");
18380 }
18381 if (SWIG_arg_fail(1)) SWIG_fail;
18382 }
18383 {
18384 if (!wxPyCheckForApp()) SWIG_fail;
18385 PyThreadState* __tstate = wxPyBeginAllowThreads();
18386 result = (wxPrinterDC *)new wxPrinterDC((wxPrintData const &)*arg1);
18387
18388 wxPyEndAllowThreads(__tstate);
18389 if (PyErr_Occurred()) SWIG_fail;
18390 }
18391 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrinterDC, 1);
18392 return resultobj;
18393 fail:
18394 return NULL;
18395 }
18396
18397
18398 static PyObject * PrinterDC_swigregister(PyObject *, PyObject *args) {
18399 PyObject *obj;
18400 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18401 SWIG_TypeClientData(SWIGTYPE_p_wxPrinterDC, obj);
18402 Py_INCREF(obj);
18403 return Py_BuildValue((char *)"");
18404 }
18405 static PyObject *_wrap_new_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
18406 PyObject *resultobj;
18407 int arg1 ;
18408 int arg2 ;
18409 int arg3 = (int) true ;
18410 int arg4 = (int) 1 ;
18411 wxImageList *result;
18412 PyObject * obj0 = 0 ;
18413 PyObject * obj1 = 0 ;
18414 PyObject * obj2 = 0 ;
18415 PyObject * obj3 = 0 ;
18416 char *kwnames[] = {
18417 (char *) "width",(char *) "height",(char *) "mask",(char *) "initialCount", NULL
18418 };
18419
18420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_ImageList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18421 {
18422 arg1 = (int)(SWIG_As_int(obj0));
18423 if (SWIG_arg_fail(1)) SWIG_fail;
18424 }
18425 {
18426 arg2 = (int)(SWIG_As_int(obj1));
18427 if (SWIG_arg_fail(2)) SWIG_fail;
18428 }
18429 if (obj2) {
18430 {
18431 arg3 = (int)(SWIG_As_int(obj2));
18432 if (SWIG_arg_fail(3)) SWIG_fail;
18433 }
18434 }
18435 if (obj3) {
18436 {
18437 arg4 = (int)(SWIG_As_int(obj3));
18438 if (SWIG_arg_fail(4)) SWIG_fail;
18439 }
18440 }
18441 {
18442 if (!wxPyCheckForApp()) SWIG_fail;
18443 PyThreadState* __tstate = wxPyBeginAllowThreads();
18444 result = (wxImageList *)new wxImageList(arg1,arg2,arg3,arg4);
18445
18446 wxPyEndAllowThreads(__tstate);
18447 if (PyErr_Occurred()) SWIG_fail;
18448 }
18449 {
18450 resultobj = wxPyMake_wxObject(result, 1);
18451 }
18452 return resultobj;
18453 fail:
18454 return NULL;
18455 }
18456
18457
18458 static PyObject *_wrap_delete_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
18459 PyObject *resultobj;
18460 wxImageList *arg1 = (wxImageList *) 0 ;
18461 PyObject * obj0 = 0 ;
18462 char *kwnames[] = {
18463 (char *) "self", NULL
18464 };
18465
18466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ImageList",kwnames,&obj0)) goto fail;
18467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18468 if (SWIG_arg_fail(1)) SWIG_fail;
18469 {
18470 PyThreadState* __tstate = wxPyBeginAllowThreads();
18471 delete arg1;
18472
18473 wxPyEndAllowThreads(__tstate);
18474 if (PyErr_Occurred()) SWIG_fail;
18475 }
18476 Py_INCREF(Py_None); resultobj = Py_None;
18477 return resultobj;
18478 fail:
18479 return NULL;
18480 }
18481
18482
18483 static PyObject *_wrap_ImageList_Add(PyObject *, PyObject *args, PyObject *kwargs) {
18484 PyObject *resultobj;
18485 wxImageList *arg1 = (wxImageList *) 0 ;
18486 wxBitmap *arg2 = 0 ;
18487 wxBitmap const &arg3_defvalue = wxNullBitmap ;
18488 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
18489 int result;
18490 PyObject * obj0 = 0 ;
18491 PyObject * obj1 = 0 ;
18492 PyObject * obj2 = 0 ;
18493 char *kwnames[] = {
18494 (char *) "self",(char *) "bitmap",(char *) "mask", NULL
18495 };
18496
18497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ImageList_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
18498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18499 if (SWIG_arg_fail(1)) SWIG_fail;
18500 {
18501 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18502 if (SWIG_arg_fail(2)) SWIG_fail;
18503 if (arg2 == NULL) {
18504 SWIG_null_ref("wxBitmap");
18505 }
18506 if (SWIG_arg_fail(2)) SWIG_fail;
18507 }
18508 if (obj2) {
18509 {
18510 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18511 if (SWIG_arg_fail(3)) SWIG_fail;
18512 if (arg3 == NULL) {
18513 SWIG_null_ref("wxBitmap");
18514 }
18515 if (SWIG_arg_fail(3)) SWIG_fail;
18516 }
18517 }
18518 {
18519 PyThreadState* __tstate = wxPyBeginAllowThreads();
18520 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
18521
18522 wxPyEndAllowThreads(__tstate);
18523 if (PyErr_Occurred()) SWIG_fail;
18524 }
18525 {
18526 resultobj = SWIG_From_int((int)(result));
18527 }
18528 return resultobj;
18529 fail:
18530 return NULL;
18531 }
18532
18533
18534 static PyObject *_wrap_ImageList_AddWithColourMask(PyObject *, PyObject *args, PyObject *kwargs) {
18535 PyObject *resultobj;
18536 wxImageList *arg1 = (wxImageList *) 0 ;
18537 wxBitmap *arg2 = 0 ;
18538 wxColour *arg3 = 0 ;
18539 int result;
18540 wxColour temp3 ;
18541 PyObject * obj0 = 0 ;
18542 PyObject * obj1 = 0 ;
18543 PyObject * obj2 = 0 ;
18544 char *kwnames[] = {
18545 (char *) "self",(char *) "bitmap",(char *) "maskColour", NULL
18546 };
18547
18548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_AddWithColourMask",kwnames,&obj0,&obj1,&obj2)) goto fail;
18549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18550 if (SWIG_arg_fail(1)) SWIG_fail;
18551 {
18552 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18553 if (SWIG_arg_fail(2)) SWIG_fail;
18554 if (arg2 == NULL) {
18555 SWIG_null_ref("wxBitmap");
18556 }
18557 if (SWIG_arg_fail(2)) SWIG_fail;
18558 }
18559 {
18560 arg3 = &temp3;
18561 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
18562 }
18563 {
18564 PyThreadState* __tstate = wxPyBeginAllowThreads();
18565 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxColour const &)*arg3);
18566
18567 wxPyEndAllowThreads(__tstate);
18568 if (PyErr_Occurred()) SWIG_fail;
18569 }
18570 {
18571 resultobj = SWIG_From_int((int)(result));
18572 }
18573 return resultobj;
18574 fail:
18575 return NULL;
18576 }
18577
18578
18579 static PyObject *_wrap_ImageList_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
18580 PyObject *resultobj;
18581 wxImageList *arg1 = (wxImageList *) 0 ;
18582 wxIcon *arg2 = 0 ;
18583 int result;
18584 PyObject * obj0 = 0 ;
18585 PyObject * obj1 = 0 ;
18586 char *kwnames[] = {
18587 (char *) "self",(char *) "icon", NULL
18588 };
18589
18590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_AddIcon",kwnames,&obj0,&obj1)) goto fail;
18591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18592 if (SWIG_arg_fail(1)) SWIG_fail;
18593 {
18594 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
18595 if (SWIG_arg_fail(2)) SWIG_fail;
18596 if (arg2 == NULL) {
18597 SWIG_null_ref("wxIcon");
18598 }
18599 if (SWIG_arg_fail(2)) SWIG_fail;
18600 }
18601 {
18602 PyThreadState* __tstate = wxPyBeginAllowThreads();
18603 result = (int)(arg1)->Add((wxIcon const &)*arg2);
18604
18605 wxPyEndAllowThreads(__tstate);
18606 if (PyErr_Occurred()) SWIG_fail;
18607 }
18608 {
18609 resultobj = SWIG_From_int((int)(result));
18610 }
18611 return resultobj;
18612 fail:
18613 return NULL;
18614 }
18615
18616
18617 static PyObject *_wrap_ImageList_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
18618 PyObject *resultobj;
18619 wxImageList *arg1 = (wxImageList *) 0 ;
18620 int arg2 ;
18621 SwigValueWrapper<wxBitmap > result;
18622 PyObject * obj0 = 0 ;
18623 PyObject * obj1 = 0 ;
18624 char *kwnames[] = {
18625 (char *) "self",(char *) "index", NULL
18626 };
18627
18628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetBitmap",kwnames,&obj0,&obj1)) goto fail;
18629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18630 if (SWIG_arg_fail(1)) SWIG_fail;
18631 {
18632 arg2 = (int)(SWIG_As_int(obj1));
18633 if (SWIG_arg_fail(2)) SWIG_fail;
18634 }
18635 {
18636 PyThreadState* __tstate = wxPyBeginAllowThreads();
18637 result = ((wxImageList const *)arg1)->GetBitmap(arg2);
18638
18639 wxPyEndAllowThreads(__tstate);
18640 if (PyErr_Occurred()) SWIG_fail;
18641 }
18642 {
18643 wxBitmap * resultptr;
18644 resultptr = new wxBitmap((wxBitmap &)(result));
18645 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
18646 }
18647 return resultobj;
18648 fail:
18649 return NULL;
18650 }
18651
18652
18653 static PyObject *_wrap_ImageList_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
18654 PyObject *resultobj;
18655 wxImageList *arg1 = (wxImageList *) 0 ;
18656 int arg2 ;
18657 wxIcon result;
18658 PyObject * obj0 = 0 ;
18659 PyObject * obj1 = 0 ;
18660 char *kwnames[] = {
18661 (char *) "self",(char *) "index", NULL
18662 };
18663
18664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetIcon",kwnames,&obj0,&obj1)) goto fail;
18665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18666 if (SWIG_arg_fail(1)) SWIG_fail;
18667 {
18668 arg2 = (int)(SWIG_As_int(obj1));
18669 if (SWIG_arg_fail(2)) SWIG_fail;
18670 }
18671 {
18672 PyThreadState* __tstate = wxPyBeginAllowThreads();
18673 result = ((wxImageList const *)arg1)->GetIcon(arg2);
18674
18675 wxPyEndAllowThreads(__tstate);
18676 if (PyErr_Occurred()) SWIG_fail;
18677 }
18678 {
18679 wxIcon * resultptr;
18680 resultptr = new wxIcon((wxIcon &)(result));
18681 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
18682 }
18683 return resultobj;
18684 fail:
18685 return NULL;
18686 }
18687
18688
18689 static PyObject *_wrap_ImageList_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
18690 PyObject *resultobj;
18691 wxImageList *arg1 = (wxImageList *) 0 ;
18692 int arg2 ;
18693 wxBitmap *arg3 = 0 ;
18694 bool result;
18695 PyObject * obj0 = 0 ;
18696 PyObject * obj1 = 0 ;
18697 PyObject * obj2 = 0 ;
18698 char *kwnames[] = {
18699 (char *) "self",(char *) "index",(char *) "bitmap", NULL
18700 };
18701
18702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_Replace",kwnames,&obj0,&obj1,&obj2)) goto fail;
18703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18704 if (SWIG_arg_fail(1)) SWIG_fail;
18705 {
18706 arg2 = (int)(SWIG_As_int(obj1));
18707 if (SWIG_arg_fail(2)) SWIG_fail;
18708 }
18709 {
18710 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18711 if (SWIG_arg_fail(3)) SWIG_fail;
18712 if (arg3 == NULL) {
18713 SWIG_null_ref("wxBitmap");
18714 }
18715 if (SWIG_arg_fail(3)) SWIG_fail;
18716 }
18717 {
18718 PyThreadState* __tstate = wxPyBeginAllowThreads();
18719 result = (bool)(arg1)->Replace(arg2,(wxBitmap const &)*arg3);
18720
18721 wxPyEndAllowThreads(__tstate);
18722 if (PyErr_Occurred()) SWIG_fail;
18723 }
18724 {
18725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18726 }
18727 return resultobj;
18728 fail:
18729 return NULL;
18730 }
18731
18732
18733 static PyObject *_wrap_ImageList_Draw(PyObject *, PyObject *args, PyObject *kwargs) {
18734 PyObject *resultobj;
18735 wxImageList *arg1 = (wxImageList *) 0 ;
18736 int arg2 ;
18737 wxDC *arg3 = 0 ;
18738 int arg4 ;
18739 int arg5 ;
18740 int arg6 = (int) wxIMAGELIST_DRAW_NORMAL ;
18741 bool arg7 = (bool) (bool)false ;
18742 bool result;
18743 PyObject * obj0 = 0 ;
18744 PyObject * obj1 = 0 ;
18745 PyObject * obj2 = 0 ;
18746 PyObject * obj3 = 0 ;
18747 PyObject * obj4 = 0 ;
18748 PyObject * obj5 = 0 ;
18749 PyObject * obj6 = 0 ;
18750 char *kwnames[] = {
18751 (char *) "self",(char *) "index",(char *) "dc",(char *) "x",(char *) "x",(char *) "flags",(char *) "solidBackground", NULL
18752 };
18753
18754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OO:ImageList_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
18755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18756 if (SWIG_arg_fail(1)) SWIG_fail;
18757 {
18758 arg2 = (int)(SWIG_As_int(obj1));
18759 if (SWIG_arg_fail(2)) SWIG_fail;
18760 }
18761 {
18762 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18763 if (SWIG_arg_fail(3)) SWIG_fail;
18764 if (arg3 == NULL) {
18765 SWIG_null_ref("wxDC");
18766 }
18767 if (SWIG_arg_fail(3)) SWIG_fail;
18768 }
18769 {
18770 arg4 = (int)(SWIG_As_int(obj3));
18771 if (SWIG_arg_fail(4)) SWIG_fail;
18772 }
18773 {
18774 arg5 = (int)(SWIG_As_int(obj4));
18775 if (SWIG_arg_fail(5)) SWIG_fail;
18776 }
18777 if (obj5) {
18778 {
18779 arg6 = (int)(SWIG_As_int(obj5));
18780 if (SWIG_arg_fail(6)) SWIG_fail;
18781 }
18782 }
18783 if (obj6) {
18784 {
18785 arg7 = (bool const)(SWIG_As_bool(obj6));
18786 if (SWIG_arg_fail(7)) SWIG_fail;
18787 }
18788 }
18789 {
18790 PyThreadState* __tstate = wxPyBeginAllowThreads();
18791 result = (bool)(arg1)->Draw(arg2,*arg3,arg4,arg5,arg6,arg7);
18792
18793 wxPyEndAllowThreads(__tstate);
18794 if (PyErr_Occurred()) SWIG_fail;
18795 }
18796 {
18797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18798 }
18799 return resultobj;
18800 fail:
18801 return NULL;
18802 }
18803
18804
18805 static PyObject *_wrap_ImageList_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
18806 PyObject *resultobj;
18807 wxImageList *arg1 = (wxImageList *) 0 ;
18808 int result;
18809 PyObject * obj0 = 0 ;
18810 char *kwnames[] = {
18811 (char *) "self", NULL
18812 };
18813
18814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_GetImageCount",kwnames,&obj0)) goto fail;
18815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18816 if (SWIG_arg_fail(1)) SWIG_fail;
18817 {
18818 PyThreadState* __tstate = wxPyBeginAllowThreads();
18819 result = (int)(arg1)->GetImageCount();
18820
18821 wxPyEndAllowThreads(__tstate);
18822 if (PyErr_Occurred()) SWIG_fail;
18823 }
18824 {
18825 resultobj = SWIG_From_int((int)(result));
18826 }
18827 return resultobj;
18828 fail:
18829 return NULL;
18830 }
18831
18832
18833 static PyObject *_wrap_ImageList_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
18834 PyObject *resultobj;
18835 wxImageList *arg1 = (wxImageList *) 0 ;
18836 int arg2 ;
18837 bool result;
18838 PyObject * obj0 = 0 ;
18839 PyObject * obj1 = 0 ;
18840 char *kwnames[] = {
18841 (char *) "self",(char *) "index", NULL
18842 };
18843
18844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_Remove",kwnames,&obj0,&obj1)) goto fail;
18845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18846 if (SWIG_arg_fail(1)) SWIG_fail;
18847 {
18848 arg2 = (int)(SWIG_As_int(obj1));
18849 if (SWIG_arg_fail(2)) SWIG_fail;
18850 }
18851 {
18852 PyThreadState* __tstate = wxPyBeginAllowThreads();
18853 result = (bool)(arg1)->Remove(arg2);
18854
18855 wxPyEndAllowThreads(__tstate);
18856 if (PyErr_Occurred()) SWIG_fail;
18857 }
18858 {
18859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18860 }
18861 return resultobj;
18862 fail:
18863 return NULL;
18864 }
18865
18866
18867 static PyObject *_wrap_ImageList_RemoveAll(PyObject *, PyObject *args, PyObject *kwargs) {
18868 PyObject *resultobj;
18869 wxImageList *arg1 = (wxImageList *) 0 ;
18870 bool result;
18871 PyObject * obj0 = 0 ;
18872 char *kwnames[] = {
18873 (char *) "self", NULL
18874 };
18875
18876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_RemoveAll",kwnames,&obj0)) goto fail;
18877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18878 if (SWIG_arg_fail(1)) SWIG_fail;
18879 {
18880 PyThreadState* __tstate = wxPyBeginAllowThreads();
18881 result = (bool)(arg1)->RemoveAll();
18882
18883 wxPyEndAllowThreads(__tstate);
18884 if (PyErr_Occurred()) SWIG_fail;
18885 }
18886 {
18887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18888 }
18889 return resultobj;
18890 fail:
18891 return NULL;
18892 }
18893
18894
18895 static PyObject *_wrap_ImageList_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18896 PyObject *resultobj;
18897 wxImageList *arg1 = (wxImageList *) 0 ;
18898 int arg2 ;
18899 int *arg3 = 0 ;
18900 int *arg4 = 0 ;
18901 int temp3 ;
18902 int res3 = 0 ;
18903 int temp4 ;
18904 int res4 = 0 ;
18905 PyObject * obj0 = 0 ;
18906 PyObject * obj1 = 0 ;
18907 char *kwnames[] = {
18908 (char *) "self",(char *) "index", NULL
18909 };
18910
18911 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18912 arg4 = &temp4; res4 = SWIG_NEWOBJ;
18913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetSize",kwnames,&obj0,&obj1)) goto fail;
18914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18915 if (SWIG_arg_fail(1)) SWIG_fail;
18916 {
18917 arg2 = (int)(SWIG_As_int(obj1));
18918 if (SWIG_arg_fail(2)) SWIG_fail;
18919 }
18920 {
18921 PyThreadState* __tstate = wxPyBeginAllowThreads();
18922 (arg1)->GetSize(arg2,*arg3,*arg4);
18923
18924 wxPyEndAllowThreads(__tstate);
18925 if (PyErr_Occurred()) SWIG_fail;
18926 }
18927 Py_INCREF(Py_None); resultobj = Py_None;
18928 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18929 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18930 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
18931 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
18932 return resultobj;
18933 fail:
18934 return NULL;
18935 }
18936
18937
18938 static PyObject * ImageList_swigregister(PyObject *, PyObject *args) {
18939 PyObject *obj;
18940 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18941 SWIG_TypeClientData(SWIGTYPE_p_wxImageList, obj);
18942 Py_INCREF(obj);
18943 return Py_BuildValue((char *)"");
18944 }
18945 static int _wrap_NORMAL_FONT_set(PyObject *) {
18946 PyErr_SetString(PyExc_TypeError,"Variable NORMAL_FONT is read-only.");
18947 return 1;
18948 }
18949
18950
18951 static PyObject *_wrap_NORMAL_FONT_get(void) {
18952 PyObject *pyobj;
18953
18954 pyobj = SWIG_NewPointerObj((void *)(wxNORMAL_FONT), SWIGTYPE_p_wxFont, 0);
18955 return pyobj;
18956 }
18957
18958
18959 static int _wrap_SMALL_FONT_set(PyObject *) {
18960 PyErr_SetString(PyExc_TypeError,"Variable SMALL_FONT is read-only.");
18961 return 1;
18962 }
18963
18964
18965 static PyObject *_wrap_SMALL_FONT_get(void) {
18966 PyObject *pyobj;
18967
18968 pyobj = SWIG_NewPointerObj((void *)(wxSMALL_FONT), SWIGTYPE_p_wxFont, 0);
18969 return pyobj;
18970 }
18971
18972
18973 static int _wrap_ITALIC_FONT_set(PyObject *) {
18974 PyErr_SetString(PyExc_TypeError,"Variable ITALIC_FONT is read-only.");
18975 return 1;
18976 }
18977
18978
18979 static PyObject *_wrap_ITALIC_FONT_get(void) {
18980 PyObject *pyobj;
18981
18982 pyobj = SWIG_NewPointerObj((void *)(wxITALIC_FONT), SWIGTYPE_p_wxFont, 0);
18983 return pyobj;
18984 }
18985
18986
18987 static int _wrap_SWISS_FONT_set(PyObject *) {
18988 PyErr_SetString(PyExc_TypeError,"Variable SWISS_FONT is read-only.");
18989 return 1;
18990 }
18991
18992
18993 static PyObject *_wrap_SWISS_FONT_get(void) {
18994 PyObject *pyobj;
18995
18996 pyobj = SWIG_NewPointerObj((void *)(wxSWISS_FONT), SWIGTYPE_p_wxFont, 0);
18997 return pyobj;
18998 }
18999
19000
19001 static int _wrap_RED_PEN_set(PyObject *) {
19002 PyErr_SetString(PyExc_TypeError,"Variable RED_PEN is read-only.");
19003 return 1;
19004 }
19005
19006
19007 static PyObject *_wrap_RED_PEN_get(void) {
19008 PyObject *pyobj;
19009
19010 pyobj = SWIG_NewPointerObj((void *)(wxRED_PEN), SWIGTYPE_p_wxPen, 0);
19011 return pyobj;
19012 }
19013
19014
19015 static int _wrap_CYAN_PEN_set(PyObject *) {
19016 PyErr_SetString(PyExc_TypeError,"Variable CYAN_PEN is read-only.");
19017 return 1;
19018 }
19019
19020
19021 static PyObject *_wrap_CYAN_PEN_get(void) {
19022 PyObject *pyobj;
19023
19024 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_PEN), SWIGTYPE_p_wxPen, 0);
19025 return pyobj;
19026 }
19027
19028
19029 static int _wrap_GREEN_PEN_set(PyObject *) {
19030 PyErr_SetString(PyExc_TypeError,"Variable GREEN_PEN is read-only.");
19031 return 1;
19032 }
19033
19034
19035 static PyObject *_wrap_GREEN_PEN_get(void) {
19036 PyObject *pyobj;
19037
19038 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_PEN), SWIGTYPE_p_wxPen, 0);
19039 return pyobj;
19040 }
19041
19042
19043 static int _wrap_BLACK_PEN_set(PyObject *) {
19044 PyErr_SetString(PyExc_TypeError,"Variable BLACK_PEN is read-only.");
19045 return 1;
19046 }
19047
19048
19049 static PyObject *_wrap_BLACK_PEN_get(void) {
19050 PyObject *pyobj;
19051
19052 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_PEN), SWIGTYPE_p_wxPen, 0);
19053 return pyobj;
19054 }
19055
19056
19057 static int _wrap_WHITE_PEN_set(PyObject *) {
19058 PyErr_SetString(PyExc_TypeError,"Variable WHITE_PEN is read-only.");
19059 return 1;
19060 }
19061
19062
19063 static PyObject *_wrap_WHITE_PEN_get(void) {
19064 PyObject *pyobj;
19065
19066 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_PEN), SWIGTYPE_p_wxPen, 0);
19067 return pyobj;
19068 }
19069
19070
19071 static int _wrap_TRANSPARENT_PEN_set(PyObject *) {
19072 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_PEN is read-only.");
19073 return 1;
19074 }
19075
19076
19077 static PyObject *_wrap_TRANSPARENT_PEN_get(void) {
19078 PyObject *pyobj;
19079
19080 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_PEN), SWIGTYPE_p_wxPen, 0);
19081 return pyobj;
19082 }
19083
19084
19085 static int _wrap_BLACK_DASHED_PEN_set(PyObject *) {
19086 PyErr_SetString(PyExc_TypeError,"Variable BLACK_DASHED_PEN is read-only.");
19087 return 1;
19088 }
19089
19090
19091 static PyObject *_wrap_BLACK_DASHED_PEN_get(void) {
19092 PyObject *pyobj;
19093
19094 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_DASHED_PEN), SWIGTYPE_p_wxPen, 0);
19095 return pyobj;
19096 }
19097
19098
19099 static int _wrap_GREY_PEN_set(PyObject *) {
19100 PyErr_SetString(PyExc_TypeError,"Variable GREY_PEN is read-only.");
19101 return 1;
19102 }
19103
19104
19105 static PyObject *_wrap_GREY_PEN_get(void) {
19106 PyObject *pyobj;
19107
19108 pyobj = SWIG_NewPointerObj((void *)(wxGREY_PEN), SWIGTYPE_p_wxPen, 0);
19109 return pyobj;
19110 }
19111
19112
19113 static int _wrap_MEDIUM_GREY_PEN_set(PyObject *) {
19114 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_PEN is read-only.");
19115 return 1;
19116 }
19117
19118
19119 static PyObject *_wrap_MEDIUM_GREY_PEN_get(void) {
19120 PyObject *pyobj;
19121
19122 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_PEN), SWIGTYPE_p_wxPen, 0);
19123 return pyobj;
19124 }
19125
19126
19127 static int _wrap_LIGHT_GREY_PEN_set(PyObject *) {
19128 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_PEN is read-only.");
19129 return 1;
19130 }
19131
19132
19133 static PyObject *_wrap_LIGHT_GREY_PEN_get(void) {
19134 PyObject *pyobj;
19135
19136 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_PEN), SWIGTYPE_p_wxPen, 0);
19137 return pyobj;
19138 }
19139
19140
19141 static int _wrap_BLUE_BRUSH_set(PyObject *) {
19142 PyErr_SetString(PyExc_TypeError,"Variable BLUE_BRUSH is read-only.");
19143 return 1;
19144 }
19145
19146
19147 static PyObject *_wrap_BLUE_BRUSH_get(void) {
19148 PyObject *pyobj;
19149
19150 pyobj = SWIG_NewPointerObj((void *)(wxBLUE_BRUSH), SWIGTYPE_p_wxBrush, 0);
19151 return pyobj;
19152 }
19153
19154
19155 static int _wrap_GREEN_BRUSH_set(PyObject *) {
19156 PyErr_SetString(PyExc_TypeError,"Variable GREEN_BRUSH is read-only.");
19157 return 1;
19158 }
19159
19160
19161 static PyObject *_wrap_GREEN_BRUSH_get(void) {
19162 PyObject *pyobj;
19163
19164 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_BRUSH), SWIGTYPE_p_wxBrush, 0);
19165 return pyobj;
19166 }
19167
19168
19169 static int _wrap_WHITE_BRUSH_set(PyObject *) {
19170 PyErr_SetString(PyExc_TypeError,"Variable WHITE_BRUSH is read-only.");
19171 return 1;
19172 }
19173
19174
19175 static PyObject *_wrap_WHITE_BRUSH_get(void) {
19176 PyObject *pyobj;
19177
19178 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_BRUSH), SWIGTYPE_p_wxBrush, 0);
19179 return pyobj;
19180 }
19181
19182
19183 static int _wrap_BLACK_BRUSH_set(PyObject *) {
19184 PyErr_SetString(PyExc_TypeError,"Variable BLACK_BRUSH is read-only.");
19185 return 1;
19186 }
19187
19188
19189 static PyObject *_wrap_BLACK_BRUSH_get(void) {
19190 PyObject *pyobj;
19191
19192 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_BRUSH), SWIGTYPE_p_wxBrush, 0);
19193 return pyobj;
19194 }
19195
19196
19197 static int _wrap_TRANSPARENT_BRUSH_set(PyObject *) {
19198 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_BRUSH is read-only.");
19199 return 1;
19200 }
19201
19202
19203 static PyObject *_wrap_TRANSPARENT_BRUSH_get(void) {
19204 PyObject *pyobj;
19205
19206 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_BRUSH), SWIGTYPE_p_wxBrush, 0);
19207 return pyobj;
19208 }
19209
19210
19211 static int _wrap_CYAN_BRUSH_set(PyObject *) {
19212 PyErr_SetString(PyExc_TypeError,"Variable CYAN_BRUSH is read-only.");
19213 return 1;
19214 }
19215
19216
19217 static PyObject *_wrap_CYAN_BRUSH_get(void) {
19218 PyObject *pyobj;
19219
19220 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_BRUSH), SWIGTYPE_p_wxBrush, 0);
19221 return pyobj;
19222 }
19223
19224
19225 static int _wrap_RED_BRUSH_set(PyObject *) {
19226 PyErr_SetString(PyExc_TypeError,"Variable RED_BRUSH is read-only.");
19227 return 1;
19228 }
19229
19230
19231 static PyObject *_wrap_RED_BRUSH_get(void) {
19232 PyObject *pyobj;
19233
19234 pyobj = SWIG_NewPointerObj((void *)(wxRED_BRUSH), SWIGTYPE_p_wxBrush, 0);
19235 return pyobj;
19236 }
19237
19238
19239 static int _wrap_GREY_BRUSH_set(PyObject *) {
19240 PyErr_SetString(PyExc_TypeError,"Variable GREY_BRUSH is read-only.");
19241 return 1;
19242 }
19243
19244
19245 static PyObject *_wrap_GREY_BRUSH_get(void) {
19246 PyObject *pyobj;
19247
19248 pyobj = SWIG_NewPointerObj((void *)(wxGREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19249 return pyobj;
19250 }
19251
19252
19253 static int _wrap_MEDIUM_GREY_BRUSH_set(PyObject *) {
19254 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_BRUSH is read-only.");
19255 return 1;
19256 }
19257
19258
19259 static PyObject *_wrap_MEDIUM_GREY_BRUSH_get(void) {
19260 PyObject *pyobj;
19261
19262 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19263 return pyobj;
19264 }
19265
19266
19267 static int _wrap_LIGHT_GREY_BRUSH_set(PyObject *) {
19268 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_BRUSH is read-only.");
19269 return 1;
19270 }
19271
19272
19273 static PyObject *_wrap_LIGHT_GREY_BRUSH_get(void) {
19274 PyObject *pyobj;
19275
19276 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19277 return pyobj;
19278 }
19279
19280
19281 static int _wrap_BLACK_set(PyObject *) {
19282 PyErr_SetString(PyExc_TypeError,"Variable BLACK is read-only.");
19283 return 1;
19284 }
19285
19286
19287 static PyObject *_wrap_BLACK_get(void) {
19288 PyObject *pyobj;
19289
19290 pyobj = SWIG_NewPointerObj((void *)(wxBLACK), SWIGTYPE_p_wxColour, 0);
19291 return pyobj;
19292 }
19293
19294
19295 static int _wrap_WHITE_set(PyObject *) {
19296 PyErr_SetString(PyExc_TypeError,"Variable WHITE is read-only.");
19297 return 1;
19298 }
19299
19300
19301 static PyObject *_wrap_WHITE_get(void) {
19302 PyObject *pyobj;
19303
19304 pyobj = SWIG_NewPointerObj((void *)(wxWHITE), SWIGTYPE_p_wxColour, 0);
19305 return pyobj;
19306 }
19307
19308
19309 static int _wrap_RED_set(PyObject *) {
19310 PyErr_SetString(PyExc_TypeError,"Variable RED is read-only.");
19311 return 1;
19312 }
19313
19314
19315 static PyObject *_wrap_RED_get(void) {
19316 PyObject *pyobj;
19317
19318 pyobj = SWIG_NewPointerObj((void *)(wxRED), SWIGTYPE_p_wxColour, 0);
19319 return pyobj;
19320 }
19321
19322
19323 static int _wrap_BLUE_set(PyObject *) {
19324 PyErr_SetString(PyExc_TypeError,"Variable BLUE is read-only.");
19325 return 1;
19326 }
19327
19328
19329 static PyObject *_wrap_BLUE_get(void) {
19330 PyObject *pyobj;
19331
19332 pyobj = SWIG_NewPointerObj((void *)(wxBLUE), SWIGTYPE_p_wxColour, 0);
19333 return pyobj;
19334 }
19335
19336
19337 static int _wrap_GREEN_set(PyObject *) {
19338 PyErr_SetString(PyExc_TypeError,"Variable GREEN is read-only.");
19339 return 1;
19340 }
19341
19342
19343 static PyObject *_wrap_GREEN_get(void) {
19344 PyObject *pyobj;
19345
19346 pyobj = SWIG_NewPointerObj((void *)(wxGREEN), SWIGTYPE_p_wxColour, 0);
19347 return pyobj;
19348 }
19349
19350
19351 static int _wrap_CYAN_set(PyObject *) {
19352 PyErr_SetString(PyExc_TypeError,"Variable CYAN is read-only.");
19353 return 1;
19354 }
19355
19356
19357 static PyObject *_wrap_CYAN_get(void) {
19358 PyObject *pyobj;
19359
19360 pyobj = SWIG_NewPointerObj((void *)(wxCYAN), SWIGTYPE_p_wxColour, 0);
19361 return pyobj;
19362 }
19363
19364
19365 static int _wrap_LIGHT_GREY_set(PyObject *) {
19366 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY is read-only.");
19367 return 1;
19368 }
19369
19370
19371 static PyObject *_wrap_LIGHT_GREY_get(void) {
19372 PyObject *pyobj;
19373
19374 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY), SWIGTYPE_p_wxColour, 0);
19375 return pyobj;
19376 }
19377
19378
19379 static int _wrap_STANDARD_CURSOR_set(PyObject *) {
19380 PyErr_SetString(PyExc_TypeError,"Variable STANDARD_CURSOR is read-only.");
19381 return 1;
19382 }
19383
19384
19385 static PyObject *_wrap_STANDARD_CURSOR_get(void) {
19386 PyObject *pyobj;
19387
19388 pyobj = SWIG_NewPointerObj((void *)(wxSTANDARD_CURSOR), SWIGTYPE_p_wxCursor, 0);
19389 return pyobj;
19390 }
19391
19392
19393 static int _wrap_HOURGLASS_CURSOR_set(PyObject *) {
19394 PyErr_SetString(PyExc_TypeError,"Variable HOURGLASS_CURSOR is read-only.");
19395 return 1;
19396 }
19397
19398
19399 static PyObject *_wrap_HOURGLASS_CURSOR_get(void) {
19400 PyObject *pyobj;
19401
19402 pyobj = SWIG_NewPointerObj((void *)(wxHOURGLASS_CURSOR), SWIGTYPE_p_wxCursor, 0);
19403 return pyobj;
19404 }
19405
19406
19407 static int _wrap_CROSS_CURSOR_set(PyObject *) {
19408 PyErr_SetString(PyExc_TypeError,"Variable CROSS_CURSOR is read-only.");
19409 return 1;
19410 }
19411
19412
19413 static PyObject *_wrap_CROSS_CURSOR_get(void) {
19414 PyObject *pyobj;
19415
19416 pyobj = SWIG_NewPointerObj((void *)(wxCROSS_CURSOR), SWIGTYPE_p_wxCursor, 0);
19417 return pyobj;
19418 }
19419
19420
19421 static int _wrap_NullBitmap_set(PyObject *) {
19422 PyErr_SetString(PyExc_TypeError,"Variable NullBitmap is read-only.");
19423 return 1;
19424 }
19425
19426
19427 static PyObject *_wrap_NullBitmap_get(void) {
19428 PyObject *pyobj;
19429
19430 pyobj = SWIG_NewPointerObj((void *)(&wxNullBitmap), SWIGTYPE_p_wxBitmap, 0);
19431 return pyobj;
19432 }
19433
19434
19435 static int _wrap_NullIcon_set(PyObject *) {
19436 PyErr_SetString(PyExc_TypeError,"Variable NullIcon is read-only.");
19437 return 1;
19438 }
19439
19440
19441 static PyObject *_wrap_NullIcon_get(void) {
19442 PyObject *pyobj;
19443
19444 pyobj = SWIG_NewPointerObj((void *)(&wxNullIcon), SWIGTYPE_p_wxIcon, 0);
19445 return pyobj;
19446 }
19447
19448
19449 static int _wrap_NullCursor_set(PyObject *) {
19450 PyErr_SetString(PyExc_TypeError,"Variable NullCursor is read-only.");
19451 return 1;
19452 }
19453
19454
19455 static PyObject *_wrap_NullCursor_get(void) {
19456 PyObject *pyobj;
19457
19458 pyobj = SWIG_NewPointerObj((void *)(&wxNullCursor), SWIGTYPE_p_wxCursor, 0);
19459 return pyobj;
19460 }
19461
19462
19463 static int _wrap_NullPen_set(PyObject *) {
19464 PyErr_SetString(PyExc_TypeError,"Variable NullPen is read-only.");
19465 return 1;
19466 }
19467
19468
19469 static PyObject *_wrap_NullPen_get(void) {
19470 PyObject *pyobj;
19471
19472 pyobj = SWIG_NewPointerObj((void *)(&wxNullPen), SWIGTYPE_p_wxPen, 0);
19473 return pyobj;
19474 }
19475
19476
19477 static int _wrap_NullBrush_set(PyObject *) {
19478 PyErr_SetString(PyExc_TypeError,"Variable NullBrush is read-only.");
19479 return 1;
19480 }
19481
19482
19483 static PyObject *_wrap_NullBrush_get(void) {
19484 PyObject *pyobj;
19485
19486 pyobj = SWIG_NewPointerObj((void *)(&wxNullBrush), SWIGTYPE_p_wxBrush, 0);
19487 return pyobj;
19488 }
19489
19490
19491 static int _wrap_NullPalette_set(PyObject *) {
19492 PyErr_SetString(PyExc_TypeError,"Variable NullPalette is read-only.");
19493 return 1;
19494 }
19495
19496
19497 static PyObject *_wrap_NullPalette_get(void) {
19498 PyObject *pyobj;
19499
19500 pyobj = SWIG_NewPointerObj((void *)(&wxNullPalette), SWIGTYPE_p_wxPalette, 0);
19501 return pyobj;
19502 }
19503
19504
19505 static int _wrap_NullFont_set(PyObject *) {
19506 PyErr_SetString(PyExc_TypeError,"Variable NullFont is read-only.");
19507 return 1;
19508 }
19509
19510
19511 static PyObject *_wrap_NullFont_get(void) {
19512 PyObject *pyobj;
19513
19514 pyobj = SWIG_NewPointerObj((void *)(&wxNullFont), SWIGTYPE_p_wxFont, 0);
19515 return pyobj;
19516 }
19517
19518
19519 static int _wrap_NullColour_set(PyObject *) {
19520 PyErr_SetString(PyExc_TypeError,"Variable NullColour is read-only.");
19521 return 1;
19522 }
19523
19524
19525 static PyObject *_wrap_NullColour_get(void) {
19526 PyObject *pyobj;
19527
19528 pyobj = SWIG_NewPointerObj((void *)(&wxNullColour), SWIGTYPE_p_wxColour, 0);
19529 return pyobj;
19530 }
19531
19532
19533 static PyObject *_wrap_PenList_AddPen(PyObject *, PyObject *args, PyObject *kwargs) {
19534 PyObject *resultobj;
19535 wxPenList *arg1 = (wxPenList *) 0 ;
19536 wxPen *arg2 = (wxPen *) 0 ;
19537 PyObject * obj0 = 0 ;
19538 PyObject * obj1 = 0 ;
19539 char *kwnames[] = {
19540 (char *) "self",(char *) "pen", NULL
19541 };
19542
19543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_AddPen",kwnames,&obj0,&obj1)) goto fail;
19544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19545 if (SWIG_arg_fail(1)) SWIG_fail;
19546 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
19547 if (SWIG_arg_fail(2)) SWIG_fail;
19548 {
19549 PyThreadState* __tstate = wxPyBeginAllowThreads();
19550 (arg1)->AddPen(arg2);
19551
19552 wxPyEndAllowThreads(__tstate);
19553 if (PyErr_Occurred()) SWIG_fail;
19554 }
19555 Py_INCREF(Py_None); resultobj = Py_None;
19556 return resultobj;
19557 fail:
19558 return NULL;
19559 }
19560
19561
19562 static PyObject *_wrap_PenList_FindOrCreatePen(PyObject *, PyObject *args, PyObject *kwargs) {
19563 PyObject *resultobj;
19564 wxPenList *arg1 = (wxPenList *) 0 ;
19565 wxColour *arg2 = 0 ;
19566 int arg3 ;
19567 int arg4 ;
19568 wxPen *result;
19569 wxColour temp2 ;
19570 PyObject * obj0 = 0 ;
19571 PyObject * obj1 = 0 ;
19572 PyObject * obj2 = 0 ;
19573 PyObject * obj3 = 0 ;
19574 char *kwnames[] = {
19575 (char *) "self",(char *) "colour",(char *) "width",(char *) "style", NULL
19576 };
19577
19578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PenList_FindOrCreatePen",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19580 if (SWIG_arg_fail(1)) SWIG_fail;
19581 {
19582 arg2 = &temp2;
19583 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19584 }
19585 {
19586 arg3 = (int)(SWIG_As_int(obj2));
19587 if (SWIG_arg_fail(3)) SWIG_fail;
19588 }
19589 {
19590 arg4 = (int)(SWIG_As_int(obj3));
19591 if (SWIG_arg_fail(4)) SWIG_fail;
19592 }
19593 {
19594 PyThreadState* __tstate = wxPyBeginAllowThreads();
19595 result = (wxPen *)(arg1)->FindOrCreatePen((wxColour const &)*arg2,arg3,arg4);
19596
19597 wxPyEndAllowThreads(__tstate);
19598 if (PyErr_Occurred()) SWIG_fail;
19599 }
19600 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 0);
19601 return resultobj;
19602 fail:
19603 return NULL;
19604 }
19605
19606
19607 static PyObject *_wrap_PenList_RemovePen(PyObject *, PyObject *args, PyObject *kwargs) {
19608 PyObject *resultobj;
19609 wxPenList *arg1 = (wxPenList *) 0 ;
19610 wxPen *arg2 = (wxPen *) 0 ;
19611 PyObject * obj0 = 0 ;
19612 PyObject * obj1 = 0 ;
19613 char *kwnames[] = {
19614 (char *) "self",(char *) "pen", NULL
19615 };
19616
19617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_RemovePen",kwnames,&obj0,&obj1)) goto fail;
19618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19619 if (SWIG_arg_fail(1)) SWIG_fail;
19620 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
19621 if (SWIG_arg_fail(2)) SWIG_fail;
19622 {
19623 PyThreadState* __tstate = wxPyBeginAllowThreads();
19624 (arg1)->RemovePen(arg2);
19625
19626 wxPyEndAllowThreads(__tstate);
19627 if (PyErr_Occurred()) SWIG_fail;
19628 }
19629 Py_INCREF(Py_None); resultobj = Py_None;
19630 return resultobj;
19631 fail:
19632 return NULL;
19633 }
19634
19635
19636 static PyObject *_wrap_PenList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19637 PyObject *resultobj;
19638 wxPenList *arg1 = (wxPenList *) 0 ;
19639 int result;
19640 PyObject * obj0 = 0 ;
19641 char *kwnames[] = {
19642 (char *) "self", NULL
19643 };
19644
19645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PenList_GetCount",kwnames,&obj0)) goto fail;
19646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19647 if (SWIG_arg_fail(1)) SWIG_fail;
19648 {
19649 PyThreadState* __tstate = wxPyBeginAllowThreads();
19650 result = (int)(arg1)->GetCount();
19651
19652 wxPyEndAllowThreads(__tstate);
19653 if (PyErr_Occurred()) SWIG_fail;
19654 }
19655 {
19656 resultobj = SWIG_From_int((int)(result));
19657 }
19658 return resultobj;
19659 fail:
19660 return NULL;
19661 }
19662
19663
19664 static PyObject * PenList_swigregister(PyObject *, PyObject *args) {
19665 PyObject *obj;
19666 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19667 SWIG_TypeClientData(SWIGTYPE_p_wxPenList, obj);
19668 Py_INCREF(obj);
19669 return Py_BuildValue((char *)"");
19670 }
19671 static PyObject *_wrap_BrushList_AddBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19672 PyObject *resultobj;
19673 wxBrushList *arg1 = (wxBrushList *) 0 ;
19674 wxBrush *arg2 = (wxBrush *) 0 ;
19675 PyObject * obj0 = 0 ;
19676 PyObject * obj1 = 0 ;
19677 char *kwnames[] = {
19678 (char *) "self",(char *) "brush", NULL
19679 };
19680
19681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_AddBrush",kwnames,&obj0,&obj1)) goto fail;
19682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19683 if (SWIG_arg_fail(1)) SWIG_fail;
19684 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
19685 if (SWIG_arg_fail(2)) SWIG_fail;
19686 {
19687 PyThreadState* __tstate = wxPyBeginAllowThreads();
19688 (arg1)->AddBrush(arg2);
19689
19690 wxPyEndAllowThreads(__tstate);
19691 if (PyErr_Occurred()) SWIG_fail;
19692 }
19693 Py_INCREF(Py_None); resultobj = Py_None;
19694 return resultobj;
19695 fail:
19696 return NULL;
19697 }
19698
19699
19700 static PyObject *_wrap_BrushList_FindOrCreateBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19701 PyObject *resultobj;
19702 wxBrushList *arg1 = (wxBrushList *) 0 ;
19703 wxColour *arg2 = 0 ;
19704 int arg3 = (int) wxSOLID ;
19705 wxBrush *result;
19706 wxColour temp2 ;
19707 PyObject * obj0 = 0 ;
19708 PyObject * obj1 = 0 ;
19709 PyObject * obj2 = 0 ;
19710 char *kwnames[] = {
19711 (char *) "self",(char *) "colour",(char *) "style", NULL
19712 };
19713
19714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:BrushList_FindOrCreateBrush",kwnames,&obj0,&obj1,&obj2)) goto fail;
19715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19716 if (SWIG_arg_fail(1)) SWIG_fail;
19717 {
19718 arg2 = &temp2;
19719 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19720 }
19721 if (obj2) {
19722 {
19723 arg3 = (int)(SWIG_As_int(obj2));
19724 if (SWIG_arg_fail(3)) SWIG_fail;
19725 }
19726 }
19727 {
19728 PyThreadState* __tstate = wxPyBeginAllowThreads();
19729 result = (wxBrush *)(arg1)->FindOrCreateBrush((wxColour const &)*arg2,arg3);
19730
19731 wxPyEndAllowThreads(__tstate);
19732 if (PyErr_Occurred()) SWIG_fail;
19733 }
19734 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 0);
19735 return resultobj;
19736 fail:
19737 return NULL;
19738 }
19739
19740
19741 static PyObject *_wrap_BrushList_RemoveBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19742 PyObject *resultobj;
19743 wxBrushList *arg1 = (wxBrushList *) 0 ;
19744 wxBrush *arg2 = (wxBrush *) 0 ;
19745 PyObject * obj0 = 0 ;
19746 PyObject * obj1 = 0 ;
19747 char *kwnames[] = {
19748 (char *) "self",(char *) "brush", NULL
19749 };
19750
19751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_RemoveBrush",kwnames,&obj0,&obj1)) goto fail;
19752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19753 if (SWIG_arg_fail(1)) SWIG_fail;
19754 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
19755 if (SWIG_arg_fail(2)) SWIG_fail;
19756 {
19757 PyThreadState* __tstate = wxPyBeginAllowThreads();
19758 (arg1)->RemoveBrush(arg2);
19759
19760 wxPyEndAllowThreads(__tstate);
19761 if (PyErr_Occurred()) SWIG_fail;
19762 }
19763 Py_INCREF(Py_None); resultobj = Py_None;
19764 return resultobj;
19765 fail:
19766 return NULL;
19767 }
19768
19769
19770 static PyObject *_wrap_BrushList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19771 PyObject *resultobj;
19772 wxBrushList *arg1 = (wxBrushList *) 0 ;
19773 int result;
19774 PyObject * obj0 = 0 ;
19775 char *kwnames[] = {
19776 (char *) "self", NULL
19777 };
19778
19779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BrushList_GetCount",kwnames,&obj0)) goto fail;
19780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19781 if (SWIG_arg_fail(1)) SWIG_fail;
19782 {
19783 PyThreadState* __tstate = wxPyBeginAllowThreads();
19784 result = (int)(arg1)->GetCount();
19785
19786 wxPyEndAllowThreads(__tstate);
19787 if (PyErr_Occurred()) SWIG_fail;
19788 }
19789 {
19790 resultobj = SWIG_From_int((int)(result));
19791 }
19792 return resultobj;
19793 fail:
19794 return NULL;
19795 }
19796
19797
19798 static PyObject * BrushList_swigregister(PyObject *, PyObject *args) {
19799 PyObject *obj;
19800 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19801 SWIG_TypeClientData(SWIGTYPE_p_wxBrushList, obj);
19802 Py_INCREF(obj);
19803 return Py_BuildValue((char *)"");
19804 }
19805 static PyObject *_wrap_new_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
19806 PyObject *resultobj;
19807 wxColourDatabase *result;
19808 char *kwnames[] = {
19809 NULL
19810 };
19811
19812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ColourDatabase",kwnames)) goto fail;
19813 {
19814 if (!wxPyCheckForApp()) SWIG_fail;
19815 PyThreadState* __tstate = wxPyBeginAllowThreads();
19816 result = (wxColourDatabase *)new wxColourDatabase();
19817
19818 wxPyEndAllowThreads(__tstate);
19819 if (PyErr_Occurred()) SWIG_fail;
19820 }
19821 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourDatabase, 1);
19822 return resultobj;
19823 fail:
19824 return NULL;
19825 }
19826
19827
19828 static PyObject *_wrap_delete_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
19829 PyObject *resultobj;
19830 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19831 PyObject * obj0 = 0 ;
19832 char *kwnames[] = {
19833 (char *) "self", NULL
19834 };
19835
19836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ColourDatabase",kwnames,&obj0)) goto fail;
19837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19838 if (SWIG_arg_fail(1)) SWIG_fail;
19839 {
19840 PyThreadState* __tstate = wxPyBeginAllowThreads();
19841 delete arg1;
19842
19843 wxPyEndAllowThreads(__tstate);
19844 if (PyErr_Occurred()) SWIG_fail;
19845 }
19846 Py_INCREF(Py_None); resultobj = Py_None;
19847 return resultobj;
19848 fail:
19849 return NULL;
19850 }
19851
19852
19853 static PyObject *_wrap_ColourDatabase_Find(PyObject *, PyObject *args, PyObject *kwargs) {
19854 PyObject *resultobj;
19855 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19856 wxString *arg2 = 0 ;
19857 wxColour result;
19858 bool temp2 = false ;
19859 PyObject * obj0 = 0 ;
19860 PyObject * obj1 = 0 ;
19861 char *kwnames[] = {
19862 (char *) "self",(char *) "name", NULL
19863 };
19864
19865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_Find",kwnames,&obj0,&obj1)) goto fail;
19866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19867 if (SWIG_arg_fail(1)) SWIG_fail;
19868 {
19869 arg2 = wxString_in_helper(obj1);
19870 if (arg2 == NULL) SWIG_fail;
19871 temp2 = true;
19872 }
19873 {
19874 PyThreadState* __tstate = wxPyBeginAllowThreads();
19875 result = ((wxColourDatabase const *)arg1)->Find((wxString const &)*arg2);
19876
19877 wxPyEndAllowThreads(__tstate);
19878 if (PyErr_Occurred()) SWIG_fail;
19879 }
19880 {
19881 wxColour * resultptr;
19882 resultptr = new wxColour((wxColour &)(result));
19883 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
19884 }
19885 {
19886 if (temp2)
19887 delete arg2;
19888 }
19889 return resultobj;
19890 fail:
19891 {
19892 if (temp2)
19893 delete arg2;
19894 }
19895 return NULL;
19896 }
19897
19898
19899 static PyObject *_wrap_ColourDatabase_FindName(PyObject *, PyObject *args, PyObject *kwargs) {
19900 PyObject *resultobj;
19901 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19902 wxColour *arg2 = 0 ;
19903 wxString result;
19904 wxColour temp2 ;
19905 PyObject * obj0 = 0 ;
19906 PyObject * obj1 = 0 ;
19907 char *kwnames[] = {
19908 (char *) "self",(char *) "colour", NULL
19909 };
19910
19911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_FindName",kwnames,&obj0,&obj1)) goto fail;
19912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19913 if (SWIG_arg_fail(1)) SWIG_fail;
19914 {
19915 arg2 = &temp2;
19916 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19917 }
19918 {
19919 PyThreadState* __tstate = wxPyBeginAllowThreads();
19920 result = ((wxColourDatabase const *)arg1)->FindName((wxColour const &)*arg2);
19921
19922 wxPyEndAllowThreads(__tstate);
19923 if (PyErr_Occurred()) SWIG_fail;
19924 }
19925 {
19926 #if wxUSE_UNICODE
19927 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19928 #else
19929 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19930 #endif
19931 }
19932 return resultobj;
19933 fail:
19934 return NULL;
19935 }
19936
19937
19938 static PyObject *_wrap_ColourDatabase_AddColour(PyObject *, PyObject *args, PyObject *kwargs) {
19939 PyObject *resultobj;
19940 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19941 wxString *arg2 = 0 ;
19942 wxColour *arg3 = 0 ;
19943 bool temp2 = false ;
19944 wxColour temp3 ;
19945 PyObject * obj0 = 0 ;
19946 PyObject * obj1 = 0 ;
19947 PyObject * obj2 = 0 ;
19948 char *kwnames[] = {
19949 (char *) "self",(char *) "name",(char *) "colour", NULL
19950 };
19951
19952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ColourDatabase_AddColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
19953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19954 if (SWIG_arg_fail(1)) SWIG_fail;
19955 {
19956 arg2 = wxString_in_helper(obj1);
19957 if (arg2 == NULL) SWIG_fail;
19958 temp2 = true;
19959 }
19960 {
19961 arg3 = &temp3;
19962 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
19963 }
19964 {
19965 PyThreadState* __tstate = wxPyBeginAllowThreads();
19966 (arg1)->AddColour((wxString const &)*arg2,(wxColour const &)*arg3);
19967
19968 wxPyEndAllowThreads(__tstate);
19969 if (PyErr_Occurred()) SWIG_fail;
19970 }
19971 Py_INCREF(Py_None); resultobj = Py_None;
19972 {
19973 if (temp2)
19974 delete arg2;
19975 }
19976 return resultobj;
19977 fail:
19978 {
19979 if (temp2)
19980 delete arg2;
19981 }
19982 return NULL;
19983 }
19984
19985
19986 static PyObject *_wrap_ColourDatabase_Append(PyObject *, PyObject *args, PyObject *kwargs) {
19987 PyObject *resultobj;
19988 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19989 wxString *arg2 = 0 ;
19990 int arg3 ;
19991 int arg4 ;
19992 int arg5 ;
19993 bool temp2 = false ;
19994 PyObject * obj0 = 0 ;
19995 PyObject * obj1 = 0 ;
19996 PyObject * obj2 = 0 ;
19997 PyObject * obj3 = 0 ;
19998 PyObject * obj4 = 0 ;
19999 char *kwnames[] = {
20000 (char *) "self",(char *) "name",(char *) "red",(char *) "green",(char *) "blue", NULL
20001 };
20002
20003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:ColourDatabase_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20005 if (SWIG_arg_fail(1)) SWIG_fail;
20006 {
20007 arg2 = wxString_in_helper(obj1);
20008 if (arg2 == NULL) SWIG_fail;
20009 temp2 = true;
20010 }
20011 {
20012 arg3 = (int)(SWIG_As_int(obj2));
20013 if (SWIG_arg_fail(3)) SWIG_fail;
20014 }
20015 {
20016 arg4 = (int)(SWIG_As_int(obj3));
20017 if (SWIG_arg_fail(4)) SWIG_fail;
20018 }
20019 {
20020 arg5 = (int)(SWIG_As_int(obj4));
20021 if (SWIG_arg_fail(5)) SWIG_fail;
20022 }
20023 {
20024 PyThreadState* __tstate = wxPyBeginAllowThreads();
20025 wxColourDatabase_Append(arg1,(wxString const &)*arg2,arg3,arg4,arg5);
20026
20027 wxPyEndAllowThreads(__tstate);
20028 if (PyErr_Occurred()) SWIG_fail;
20029 }
20030 Py_INCREF(Py_None); resultobj = Py_None;
20031 {
20032 if (temp2)
20033 delete arg2;
20034 }
20035 return resultobj;
20036 fail:
20037 {
20038 if (temp2)
20039 delete arg2;
20040 }
20041 return NULL;
20042 }
20043
20044
20045 static PyObject * ColourDatabase_swigregister(PyObject *, PyObject *args) {
20046 PyObject *obj;
20047 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20048 SWIG_TypeClientData(SWIGTYPE_p_wxColourDatabase, obj);
20049 Py_INCREF(obj);
20050 return Py_BuildValue((char *)"");
20051 }
20052 static PyObject *_wrap_FontList_AddFont(PyObject *, PyObject *args, PyObject *kwargs) {
20053 PyObject *resultobj;
20054 wxFontList *arg1 = (wxFontList *) 0 ;
20055 wxFont *arg2 = (wxFont *) 0 ;
20056 PyObject * obj0 = 0 ;
20057 PyObject * obj1 = 0 ;
20058 char *kwnames[] = {
20059 (char *) "self",(char *) "font", NULL
20060 };
20061
20062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_AddFont",kwnames,&obj0,&obj1)) goto fail;
20063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20064 if (SWIG_arg_fail(1)) SWIG_fail;
20065 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
20066 if (SWIG_arg_fail(2)) SWIG_fail;
20067 {
20068 PyThreadState* __tstate = wxPyBeginAllowThreads();
20069 (arg1)->AddFont(arg2);
20070
20071 wxPyEndAllowThreads(__tstate);
20072 if (PyErr_Occurred()) SWIG_fail;
20073 }
20074 Py_INCREF(Py_None); resultobj = Py_None;
20075 return resultobj;
20076 fail:
20077 return NULL;
20078 }
20079
20080
20081 static PyObject *_wrap_FontList_FindOrCreateFont(PyObject *, PyObject *args, PyObject *kwargs) {
20082 PyObject *resultobj;
20083 wxFontList *arg1 = (wxFontList *) 0 ;
20084 int arg2 ;
20085 int arg3 ;
20086 int arg4 ;
20087 int arg5 ;
20088 bool arg6 = (bool) false ;
20089 wxString const &arg7_defvalue = wxPyEmptyString ;
20090 wxString *arg7 = (wxString *) &arg7_defvalue ;
20091 wxFontEncoding arg8 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
20092 wxFont *result;
20093 bool temp7 = false ;
20094 PyObject * obj0 = 0 ;
20095 PyObject * obj1 = 0 ;
20096 PyObject * obj2 = 0 ;
20097 PyObject * obj3 = 0 ;
20098 PyObject * obj4 = 0 ;
20099 PyObject * obj5 = 0 ;
20100 PyObject * obj6 = 0 ;
20101 PyObject * obj7 = 0 ;
20102 char *kwnames[] = {
20103 (char *) "self",(char *) "point_size",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "facename",(char *) "encoding", NULL
20104 };
20105
20106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:FontList_FindOrCreateFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20108 if (SWIG_arg_fail(1)) SWIG_fail;
20109 {
20110 arg2 = (int)(SWIG_As_int(obj1));
20111 if (SWIG_arg_fail(2)) SWIG_fail;
20112 }
20113 {
20114 arg3 = (int)(SWIG_As_int(obj2));
20115 if (SWIG_arg_fail(3)) SWIG_fail;
20116 }
20117 {
20118 arg4 = (int)(SWIG_As_int(obj3));
20119 if (SWIG_arg_fail(4)) SWIG_fail;
20120 }
20121 {
20122 arg5 = (int)(SWIG_As_int(obj4));
20123 if (SWIG_arg_fail(5)) SWIG_fail;
20124 }
20125 if (obj5) {
20126 {
20127 arg6 = (bool)(SWIG_As_bool(obj5));
20128 if (SWIG_arg_fail(6)) SWIG_fail;
20129 }
20130 }
20131 if (obj6) {
20132 {
20133 arg7 = wxString_in_helper(obj6);
20134 if (arg7 == NULL) SWIG_fail;
20135 temp7 = true;
20136 }
20137 }
20138 if (obj7) {
20139 {
20140 arg8 = (wxFontEncoding)(SWIG_As_int(obj7));
20141 if (SWIG_arg_fail(8)) SWIG_fail;
20142 }
20143 }
20144 {
20145 PyThreadState* __tstate = wxPyBeginAllowThreads();
20146 result = (wxFont *)(arg1)->FindOrCreateFont(arg2,arg3,arg4,arg5,arg6,(wxString const &)*arg7,(wxFontEncoding )arg8);
20147
20148 wxPyEndAllowThreads(__tstate);
20149 if (PyErr_Occurred()) SWIG_fail;
20150 }
20151 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
20152 {
20153 if (temp7)
20154 delete arg7;
20155 }
20156 return resultobj;
20157 fail:
20158 {
20159 if (temp7)
20160 delete arg7;
20161 }
20162 return NULL;
20163 }
20164
20165
20166 static PyObject *_wrap_FontList_RemoveFont(PyObject *, PyObject *args, PyObject *kwargs) {
20167 PyObject *resultobj;
20168 wxFontList *arg1 = (wxFontList *) 0 ;
20169 wxFont *arg2 = (wxFont *) 0 ;
20170 PyObject * obj0 = 0 ;
20171 PyObject * obj1 = 0 ;
20172 char *kwnames[] = {
20173 (char *) "self",(char *) "font", NULL
20174 };
20175
20176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_RemoveFont",kwnames,&obj0,&obj1)) goto fail;
20177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20178 if (SWIG_arg_fail(1)) SWIG_fail;
20179 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
20180 if (SWIG_arg_fail(2)) SWIG_fail;
20181 {
20182 PyThreadState* __tstate = wxPyBeginAllowThreads();
20183 (arg1)->RemoveFont(arg2);
20184
20185 wxPyEndAllowThreads(__tstate);
20186 if (PyErr_Occurred()) SWIG_fail;
20187 }
20188 Py_INCREF(Py_None); resultobj = Py_None;
20189 return resultobj;
20190 fail:
20191 return NULL;
20192 }
20193
20194
20195 static PyObject *_wrap_FontList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
20196 PyObject *resultobj;
20197 wxFontList *arg1 = (wxFontList *) 0 ;
20198 int result;
20199 PyObject * obj0 = 0 ;
20200 char *kwnames[] = {
20201 (char *) "self", NULL
20202 };
20203
20204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontList_GetCount",kwnames,&obj0)) goto fail;
20205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20206 if (SWIG_arg_fail(1)) SWIG_fail;
20207 {
20208 PyThreadState* __tstate = wxPyBeginAllowThreads();
20209 result = (int)(arg1)->GetCount();
20210
20211 wxPyEndAllowThreads(__tstate);
20212 if (PyErr_Occurred()) SWIG_fail;
20213 }
20214 {
20215 resultobj = SWIG_From_int((int)(result));
20216 }
20217 return resultobj;
20218 fail:
20219 return NULL;
20220 }
20221
20222
20223 static PyObject * FontList_swigregister(PyObject *, PyObject *args) {
20224 PyObject *obj;
20225 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20226 SWIG_TypeClientData(SWIGTYPE_p_wxFontList, obj);
20227 Py_INCREF(obj);
20228 return Py_BuildValue((char *)"");
20229 }
20230 static int _wrap_TheFontList_set(PyObject *) {
20231 PyErr_SetString(PyExc_TypeError,"Variable TheFontList is read-only.");
20232 return 1;
20233 }
20234
20235
20236 static PyObject *_wrap_TheFontList_get(void) {
20237 PyObject *pyobj;
20238
20239 pyobj = SWIG_NewPointerObj((void *)(wxTheFontList), SWIGTYPE_p_wxFontList, 0);
20240 return pyobj;
20241 }
20242
20243
20244 static int _wrap_ThePenList_set(PyObject *) {
20245 PyErr_SetString(PyExc_TypeError,"Variable ThePenList is read-only.");
20246 return 1;
20247 }
20248
20249
20250 static PyObject *_wrap_ThePenList_get(void) {
20251 PyObject *pyobj;
20252
20253 pyobj = SWIG_NewPointerObj((void *)(wxThePenList), SWIGTYPE_p_wxPenList, 0);
20254 return pyobj;
20255 }
20256
20257
20258 static int _wrap_TheBrushList_set(PyObject *) {
20259 PyErr_SetString(PyExc_TypeError,"Variable TheBrushList is read-only.");
20260 return 1;
20261 }
20262
20263
20264 static PyObject *_wrap_TheBrushList_get(void) {
20265 PyObject *pyobj;
20266
20267 pyobj = SWIG_NewPointerObj((void *)(wxTheBrushList), SWIGTYPE_p_wxBrushList, 0);
20268 return pyobj;
20269 }
20270
20271
20272 static int _wrap_TheColourDatabase_set(PyObject *) {
20273 PyErr_SetString(PyExc_TypeError,"Variable TheColourDatabase is read-only.");
20274 return 1;
20275 }
20276
20277
20278 static PyObject *_wrap_TheColourDatabase_get(void) {
20279 PyObject *pyobj;
20280
20281 pyobj = SWIG_NewPointerObj((void *)(wxTheColourDatabase), SWIGTYPE_p_wxColourDatabase, 0);
20282 return pyobj;
20283 }
20284
20285
20286 static PyObject *_wrap_new_Effects(PyObject *, PyObject *args, PyObject *kwargs) {
20287 PyObject *resultobj;
20288 wxEffects *result;
20289 char *kwnames[] = {
20290 NULL
20291 };
20292
20293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Effects",kwnames)) goto fail;
20294 {
20295 PyThreadState* __tstate = wxPyBeginAllowThreads();
20296 result = (wxEffects *)new wxEffects();
20297
20298 wxPyEndAllowThreads(__tstate);
20299 if (PyErr_Occurred()) SWIG_fail;
20300 }
20301 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEffects, 1);
20302 return resultobj;
20303 fail:
20304 return NULL;
20305 }
20306
20307
20308 static PyObject *_wrap_Effects_GetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
20309 PyObject *resultobj;
20310 wxEffects *arg1 = (wxEffects *) 0 ;
20311 wxColour result;
20312 PyObject * obj0 = 0 ;
20313 char *kwnames[] = {
20314 (char *) "self", NULL
20315 };
20316
20317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetHighlightColour",kwnames,&obj0)) goto fail;
20318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20319 if (SWIG_arg_fail(1)) SWIG_fail;
20320 {
20321 PyThreadState* __tstate = wxPyBeginAllowThreads();
20322 result = ((wxEffects const *)arg1)->GetHighlightColour();
20323
20324 wxPyEndAllowThreads(__tstate);
20325 if (PyErr_Occurred()) SWIG_fail;
20326 }
20327 {
20328 wxColour * resultptr;
20329 resultptr = new wxColour((wxColour &)(result));
20330 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20331 }
20332 return resultobj;
20333 fail:
20334 return NULL;
20335 }
20336
20337
20338 static PyObject *_wrap_Effects_GetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20339 PyObject *resultobj;
20340 wxEffects *arg1 = (wxEffects *) 0 ;
20341 wxColour result;
20342 PyObject * obj0 = 0 ;
20343 char *kwnames[] = {
20344 (char *) "self", NULL
20345 };
20346
20347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetLightShadow",kwnames,&obj0)) goto fail;
20348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20349 if (SWIG_arg_fail(1)) SWIG_fail;
20350 {
20351 PyThreadState* __tstate = wxPyBeginAllowThreads();
20352 result = ((wxEffects const *)arg1)->GetLightShadow();
20353
20354 wxPyEndAllowThreads(__tstate);
20355 if (PyErr_Occurred()) SWIG_fail;
20356 }
20357 {
20358 wxColour * resultptr;
20359 resultptr = new wxColour((wxColour &)(result));
20360 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20361 }
20362 return resultobj;
20363 fail:
20364 return NULL;
20365 }
20366
20367
20368 static PyObject *_wrap_Effects_GetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
20369 PyObject *resultobj;
20370 wxEffects *arg1 = (wxEffects *) 0 ;
20371 wxColour result;
20372 PyObject * obj0 = 0 ;
20373 char *kwnames[] = {
20374 (char *) "self", NULL
20375 };
20376
20377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetFaceColour",kwnames,&obj0)) goto fail;
20378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20379 if (SWIG_arg_fail(1)) SWIG_fail;
20380 {
20381 PyThreadState* __tstate = wxPyBeginAllowThreads();
20382 result = ((wxEffects const *)arg1)->GetFaceColour();
20383
20384 wxPyEndAllowThreads(__tstate);
20385 if (PyErr_Occurred()) SWIG_fail;
20386 }
20387 {
20388 wxColour * resultptr;
20389 resultptr = new wxColour((wxColour &)(result));
20390 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20391 }
20392 return resultobj;
20393 fail:
20394 return NULL;
20395 }
20396
20397
20398 static PyObject *_wrap_Effects_GetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20399 PyObject *resultobj;
20400 wxEffects *arg1 = (wxEffects *) 0 ;
20401 wxColour result;
20402 PyObject * obj0 = 0 ;
20403 char *kwnames[] = {
20404 (char *) "self", NULL
20405 };
20406
20407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetMediumShadow",kwnames,&obj0)) goto fail;
20408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20409 if (SWIG_arg_fail(1)) SWIG_fail;
20410 {
20411 PyThreadState* __tstate = wxPyBeginAllowThreads();
20412 result = ((wxEffects const *)arg1)->GetMediumShadow();
20413
20414 wxPyEndAllowThreads(__tstate);
20415 if (PyErr_Occurred()) SWIG_fail;
20416 }
20417 {
20418 wxColour * resultptr;
20419 resultptr = new wxColour((wxColour &)(result));
20420 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20421 }
20422 return resultobj;
20423 fail:
20424 return NULL;
20425 }
20426
20427
20428 static PyObject *_wrap_Effects_GetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20429 PyObject *resultobj;
20430 wxEffects *arg1 = (wxEffects *) 0 ;
20431 wxColour result;
20432 PyObject * obj0 = 0 ;
20433 char *kwnames[] = {
20434 (char *) "self", NULL
20435 };
20436
20437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetDarkShadow",kwnames,&obj0)) goto fail;
20438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20439 if (SWIG_arg_fail(1)) SWIG_fail;
20440 {
20441 PyThreadState* __tstate = wxPyBeginAllowThreads();
20442 result = ((wxEffects const *)arg1)->GetDarkShadow();
20443
20444 wxPyEndAllowThreads(__tstate);
20445 if (PyErr_Occurred()) SWIG_fail;
20446 }
20447 {
20448 wxColour * resultptr;
20449 resultptr = new wxColour((wxColour &)(result));
20450 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20451 }
20452 return resultobj;
20453 fail:
20454 return NULL;
20455 }
20456
20457
20458 static PyObject *_wrap_Effects_SetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
20459 PyObject *resultobj;
20460 wxEffects *arg1 = (wxEffects *) 0 ;
20461 wxColour *arg2 = 0 ;
20462 wxColour temp2 ;
20463 PyObject * obj0 = 0 ;
20464 PyObject * obj1 = 0 ;
20465 char *kwnames[] = {
20466 (char *) "self",(char *) "c", NULL
20467 };
20468
20469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetHighlightColour",kwnames,&obj0,&obj1)) goto fail;
20470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20471 if (SWIG_arg_fail(1)) SWIG_fail;
20472 {
20473 arg2 = &temp2;
20474 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20475 }
20476 {
20477 PyThreadState* __tstate = wxPyBeginAllowThreads();
20478 (arg1)->SetHighlightColour((wxColour const &)*arg2);
20479
20480 wxPyEndAllowThreads(__tstate);
20481 if (PyErr_Occurred()) SWIG_fail;
20482 }
20483 Py_INCREF(Py_None); resultobj = Py_None;
20484 return resultobj;
20485 fail:
20486 return NULL;
20487 }
20488
20489
20490 static PyObject *_wrap_Effects_SetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20491 PyObject *resultobj;
20492 wxEffects *arg1 = (wxEffects *) 0 ;
20493 wxColour *arg2 = 0 ;
20494 wxColour temp2 ;
20495 PyObject * obj0 = 0 ;
20496 PyObject * obj1 = 0 ;
20497 char *kwnames[] = {
20498 (char *) "self",(char *) "c", NULL
20499 };
20500
20501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetLightShadow",kwnames,&obj0,&obj1)) goto fail;
20502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20503 if (SWIG_arg_fail(1)) SWIG_fail;
20504 {
20505 arg2 = &temp2;
20506 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20507 }
20508 {
20509 PyThreadState* __tstate = wxPyBeginAllowThreads();
20510 (arg1)->SetLightShadow((wxColour const &)*arg2);
20511
20512 wxPyEndAllowThreads(__tstate);
20513 if (PyErr_Occurred()) SWIG_fail;
20514 }
20515 Py_INCREF(Py_None); resultobj = Py_None;
20516 return resultobj;
20517 fail:
20518 return NULL;
20519 }
20520
20521
20522 static PyObject *_wrap_Effects_SetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
20523 PyObject *resultobj;
20524 wxEffects *arg1 = (wxEffects *) 0 ;
20525 wxColour *arg2 = 0 ;
20526 wxColour temp2 ;
20527 PyObject * obj0 = 0 ;
20528 PyObject * obj1 = 0 ;
20529 char *kwnames[] = {
20530 (char *) "self",(char *) "c", NULL
20531 };
20532
20533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetFaceColour",kwnames,&obj0,&obj1)) goto fail;
20534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20535 if (SWIG_arg_fail(1)) SWIG_fail;
20536 {
20537 arg2 = &temp2;
20538 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20539 }
20540 {
20541 PyThreadState* __tstate = wxPyBeginAllowThreads();
20542 (arg1)->SetFaceColour((wxColour const &)*arg2);
20543
20544 wxPyEndAllowThreads(__tstate);
20545 if (PyErr_Occurred()) SWIG_fail;
20546 }
20547 Py_INCREF(Py_None); resultobj = Py_None;
20548 return resultobj;
20549 fail:
20550 return NULL;
20551 }
20552
20553
20554 static PyObject *_wrap_Effects_SetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20555 PyObject *resultobj;
20556 wxEffects *arg1 = (wxEffects *) 0 ;
20557 wxColour *arg2 = 0 ;
20558 wxColour temp2 ;
20559 PyObject * obj0 = 0 ;
20560 PyObject * obj1 = 0 ;
20561 char *kwnames[] = {
20562 (char *) "self",(char *) "c", NULL
20563 };
20564
20565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetMediumShadow",kwnames,&obj0,&obj1)) goto fail;
20566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20567 if (SWIG_arg_fail(1)) SWIG_fail;
20568 {
20569 arg2 = &temp2;
20570 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20571 }
20572 {
20573 PyThreadState* __tstate = wxPyBeginAllowThreads();
20574 (arg1)->SetMediumShadow((wxColour const &)*arg2);
20575
20576 wxPyEndAllowThreads(__tstate);
20577 if (PyErr_Occurred()) SWIG_fail;
20578 }
20579 Py_INCREF(Py_None); resultobj = Py_None;
20580 return resultobj;
20581 fail:
20582 return NULL;
20583 }
20584
20585
20586 static PyObject *_wrap_Effects_SetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20587 PyObject *resultobj;
20588 wxEffects *arg1 = (wxEffects *) 0 ;
20589 wxColour *arg2 = 0 ;
20590 wxColour temp2 ;
20591 PyObject * obj0 = 0 ;
20592 PyObject * obj1 = 0 ;
20593 char *kwnames[] = {
20594 (char *) "self",(char *) "c", NULL
20595 };
20596
20597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetDarkShadow",kwnames,&obj0,&obj1)) goto fail;
20598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20599 if (SWIG_arg_fail(1)) SWIG_fail;
20600 {
20601 arg2 = &temp2;
20602 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20603 }
20604 {
20605 PyThreadState* __tstate = wxPyBeginAllowThreads();
20606 (arg1)->SetDarkShadow((wxColour const &)*arg2);
20607
20608 wxPyEndAllowThreads(__tstate);
20609 if (PyErr_Occurred()) SWIG_fail;
20610 }
20611 Py_INCREF(Py_None); resultobj = Py_None;
20612 return resultobj;
20613 fail:
20614 return NULL;
20615 }
20616
20617
20618 static PyObject *_wrap_Effects_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20619 PyObject *resultobj;
20620 wxEffects *arg1 = (wxEffects *) 0 ;
20621 wxColour *arg2 = 0 ;
20622 wxColour *arg3 = 0 ;
20623 wxColour *arg4 = 0 ;
20624 wxColour *arg5 = 0 ;
20625 wxColour *arg6 = 0 ;
20626 wxColour temp2 ;
20627 wxColour temp3 ;
20628 wxColour temp4 ;
20629 wxColour temp5 ;
20630 wxColour temp6 ;
20631 PyObject * obj0 = 0 ;
20632 PyObject * obj1 = 0 ;
20633 PyObject * obj2 = 0 ;
20634 PyObject * obj3 = 0 ;
20635 PyObject * obj4 = 0 ;
20636 PyObject * obj5 = 0 ;
20637 char *kwnames[] = {
20638 (char *) "self",(char *) "highlightColour",(char *) "lightShadow",(char *) "faceColour",(char *) "mediumShadow",(char *) "darkShadow", NULL
20639 };
20640
20641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Effects_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
20642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20643 if (SWIG_arg_fail(1)) SWIG_fail;
20644 {
20645 arg2 = &temp2;
20646 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20647 }
20648 {
20649 arg3 = &temp3;
20650 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
20651 }
20652 {
20653 arg4 = &temp4;
20654 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
20655 }
20656 {
20657 arg5 = &temp5;
20658 if ( ! wxColour_helper(obj4, &arg5)) SWIG_fail;
20659 }
20660 {
20661 arg6 = &temp6;
20662 if ( ! wxColour_helper(obj5, &arg6)) SWIG_fail;
20663 }
20664 {
20665 PyThreadState* __tstate = wxPyBeginAllowThreads();
20666 (arg1)->Set((wxColour const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,(wxColour const &)*arg5,(wxColour const &)*arg6);
20667
20668 wxPyEndAllowThreads(__tstate);
20669 if (PyErr_Occurred()) SWIG_fail;
20670 }
20671 Py_INCREF(Py_None); resultobj = Py_None;
20672 return resultobj;
20673 fail:
20674 return NULL;
20675 }
20676
20677
20678 static PyObject *_wrap_Effects_DrawSunkenEdge(PyObject *, PyObject *args, PyObject *kwargs) {
20679 PyObject *resultobj;
20680 wxEffects *arg1 = (wxEffects *) 0 ;
20681 wxDC *arg2 = 0 ;
20682 wxRect *arg3 = 0 ;
20683 int arg4 = (int) 1 ;
20684 wxRect temp3 ;
20685 PyObject * obj0 = 0 ;
20686 PyObject * obj1 = 0 ;
20687 PyObject * obj2 = 0 ;
20688 PyObject * obj3 = 0 ;
20689 char *kwnames[] = {
20690 (char *) "self",(char *) "dc",(char *) "rect",(char *) "borderSize", NULL
20691 };
20692
20693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Effects_DrawSunkenEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20695 if (SWIG_arg_fail(1)) SWIG_fail;
20696 {
20697 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20698 if (SWIG_arg_fail(2)) SWIG_fail;
20699 if (arg2 == NULL) {
20700 SWIG_null_ref("wxDC");
20701 }
20702 if (SWIG_arg_fail(2)) SWIG_fail;
20703 }
20704 {
20705 arg3 = &temp3;
20706 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
20707 }
20708 if (obj3) {
20709 {
20710 arg4 = (int)(SWIG_As_int(obj3));
20711 if (SWIG_arg_fail(4)) SWIG_fail;
20712 }
20713 }
20714 {
20715 PyThreadState* __tstate = wxPyBeginAllowThreads();
20716 (arg1)->DrawSunkenEdge(*arg2,(wxRect const &)*arg3,arg4);
20717
20718 wxPyEndAllowThreads(__tstate);
20719 if (PyErr_Occurred()) SWIG_fail;
20720 }
20721 Py_INCREF(Py_None); resultobj = Py_None;
20722 return resultobj;
20723 fail:
20724 return NULL;
20725 }
20726
20727
20728 static PyObject *_wrap_Effects_TileBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
20729 PyObject *resultobj;
20730 wxEffects *arg1 = (wxEffects *) 0 ;
20731 wxRect *arg2 = 0 ;
20732 wxDC *arg3 = 0 ;
20733 wxBitmap *arg4 = 0 ;
20734 bool result;
20735 wxRect temp2 ;
20736 PyObject * obj0 = 0 ;
20737 PyObject * obj1 = 0 ;
20738 PyObject * obj2 = 0 ;
20739 PyObject * obj3 = 0 ;
20740 char *kwnames[] = {
20741 (char *) "self",(char *) "rect",(char *) "dc",(char *) "bitmap", NULL
20742 };
20743
20744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Effects_TileBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20746 if (SWIG_arg_fail(1)) SWIG_fail;
20747 {
20748 arg2 = &temp2;
20749 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
20750 }
20751 {
20752 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20753 if (SWIG_arg_fail(3)) SWIG_fail;
20754 if (arg3 == NULL) {
20755 SWIG_null_ref("wxDC");
20756 }
20757 if (SWIG_arg_fail(3)) SWIG_fail;
20758 }
20759 {
20760 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
20761 if (SWIG_arg_fail(4)) SWIG_fail;
20762 if (arg4 == NULL) {
20763 SWIG_null_ref("wxBitmap");
20764 }
20765 if (SWIG_arg_fail(4)) SWIG_fail;
20766 }
20767 {
20768 PyThreadState* __tstate = wxPyBeginAllowThreads();
20769 result = (bool)(arg1)->TileBitmap((wxRect const &)*arg2,*arg3,*arg4);
20770
20771 wxPyEndAllowThreads(__tstate);
20772 if (PyErr_Occurred()) SWIG_fail;
20773 }
20774 {
20775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20776 }
20777 return resultobj;
20778 fail:
20779 return NULL;
20780 }
20781
20782
20783 static PyObject * Effects_swigregister(PyObject *, PyObject *args) {
20784 PyObject *obj;
20785 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20786 SWIG_TypeClientData(SWIGTYPE_p_wxEffects, obj);
20787 Py_INCREF(obj);
20788 return Py_BuildValue((char *)"");
20789 }
20790 static PyObject *_wrap_new_SplitterRenderParams(PyObject *, PyObject *args, PyObject *kwargs) {
20791 PyObject *resultobj;
20792 int arg1 ;
20793 int arg2 ;
20794 bool arg3 ;
20795 wxSplitterRenderParams *result;
20796 PyObject * obj0 = 0 ;
20797 PyObject * obj1 = 0 ;
20798 PyObject * obj2 = 0 ;
20799 char *kwnames[] = {
20800 (char *) "widthSash_",(char *) "border_",(char *) "isSens_", NULL
20801 };
20802
20803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_SplitterRenderParams",kwnames,&obj0,&obj1,&obj2)) goto fail;
20804 {
20805 arg1 = (int)(SWIG_As_int(obj0));
20806 if (SWIG_arg_fail(1)) SWIG_fail;
20807 }
20808 {
20809 arg2 = (int)(SWIG_As_int(obj1));
20810 if (SWIG_arg_fail(2)) SWIG_fail;
20811 }
20812 {
20813 arg3 = (bool)(SWIG_As_bool(obj2));
20814 if (SWIG_arg_fail(3)) SWIG_fail;
20815 }
20816 {
20817 PyThreadState* __tstate = wxPyBeginAllowThreads();
20818 result = (wxSplitterRenderParams *)new wxSplitterRenderParams(arg1,arg2,arg3);
20819
20820 wxPyEndAllowThreads(__tstate);
20821 if (PyErr_Occurred()) SWIG_fail;
20822 }
20823 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSplitterRenderParams, 1);
20824 return resultobj;
20825 fail:
20826 return NULL;
20827 }
20828
20829
20830 static PyObject *_wrap_delete_SplitterRenderParams(PyObject *, PyObject *args, PyObject *kwargs) {
20831 PyObject *resultobj;
20832 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
20833 PyObject * obj0 = 0 ;
20834 char *kwnames[] = {
20835 (char *) "self", NULL
20836 };
20837
20838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SplitterRenderParams",kwnames,&obj0)) goto fail;
20839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_EXCEPTION | 0);
20840 if (SWIG_arg_fail(1)) SWIG_fail;
20841 {
20842 PyThreadState* __tstate = wxPyBeginAllowThreads();
20843 delete arg1;
20844
20845 wxPyEndAllowThreads(__tstate);
20846 if (PyErr_Occurred()) SWIG_fail;
20847 }
20848 Py_INCREF(Py_None); resultobj = Py_None;
20849 return resultobj;
20850 fail:
20851 return NULL;
20852 }
20853
20854
20855 static PyObject *_wrap_SplitterRenderParams_widthSash_get(PyObject *, PyObject *args, PyObject *kwargs) {
20856 PyObject *resultobj;
20857 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
20858 int result;
20859 PyObject * obj0 = 0 ;
20860 char *kwnames[] = {
20861 (char *) "self", NULL
20862 };
20863
20864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterRenderParams_widthSash_get",kwnames,&obj0)) goto fail;
20865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_EXCEPTION | 0);
20866 if (SWIG_arg_fail(1)) SWIG_fail;
20867 result = (int)(int) ((arg1)->widthSash);
20868
20869 {
20870 resultobj = SWIG_From_int((int)(result));
20871 }
20872 return resultobj;
20873 fail:
20874 return NULL;
20875 }
20876
20877
20878 static PyObject *_wrap_SplitterRenderParams_border_get(PyObject *, PyObject *args, PyObject *kwargs) {
20879 PyObject *resultobj;
20880 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
20881 int result;
20882 PyObject * obj0 = 0 ;
20883 char *kwnames[] = {
20884 (char *) "self", NULL
20885 };
20886
20887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterRenderParams_border_get",kwnames,&obj0)) goto fail;
20888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_EXCEPTION | 0);
20889 if (SWIG_arg_fail(1)) SWIG_fail;
20890 result = (int)(int) ((arg1)->border);
20891
20892 {
20893 resultobj = SWIG_From_int((int)(result));
20894 }
20895 return resultobj;
20896 fail:
20897 return NULL;
20898 }
20899
20900
20901 static PyObject *_wrap_SplitterRenderParams_isHotSensitive_get(PyObject *, PyObject *args, PyObject *kwargs) {
20902 PyObject *resultobj;
20903 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
20904 bool result;
20905 PyObject * obj0 = 0 ;
20906 char *kwnames[] = {
20907 (char *) "self", NULL
20908 };
20909
20910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterRenderParams_isHotSensitive_get",kwnames,&obj0)) goto fail;
20911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_EXCEPTION | 0);
20912 if (SWIG_arg_fail(1)) SWIG_fail;
20913 result = (bool)(bool) ((arg1)->isHotSensitive);
20914
20915 {
20916 resultobj = SWIG_From_bool((bool)(result));
20917 }
20918 return resultobj;
20919 fail:
20920 return NULL;
20921 }
20922
20923
20924 static PyObject * SplitterRenderParams_swigregister(PyObject *, PyObject *args) {
20925 PyObject *obj;
20926 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20927 SWIG_TypeClientData(SWIGTYPE_p_wxSplitterRenderParams, obj);
20928 Py_INCREF(obj);
20929 return Py_BuildValue((char *)"");
20930 }
20931 static PyObject *_wrap_new_RendererVersion(PyObject *, PyObject *args, PyObject *kwargs) {
20932 PyObject *resultobj;
20933 int arg1 ;
20934 int arg2 ;
20935 wxRendererVersion *result;
20936 PyObject * obj0 = 0 ;
20937 PyObject * obj1 = 0 ;
20938 char *kwnames[] = {
20939 (char *) "version_",(char *) "age_", NULL
20940 };
20941
20942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RendererVersion",kwnames,&obj0,&obj1)) goto fail;
20943 {
20944 arg1 = (int)(SWIG_As_int(obj0));
20945 if (SWIG_arg_fail(1)) SWIG_fail;
20946 }
20947 {
20948 arg2 = (int)(SWIG_As_int(obj1));
20949 if (SWIG_arg_fail(2)) SWIG_fail;
20950 }
20951 {
20952 PyThreadState* __tstate = wxPyBeginAllowThreads();
20953 result = (wxRendererVersion *)new wxRendererVersion(arg1,arg2);
20954
20955 wxPyEndAllowThreads(__tstate);
20956 if (PyErr_Occurred()) SWIG_fail;
20957 }
20958 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRendererVersion, 1);
20959 return resultobj;
20960 fail:
20961 return NULL;
20962 }
20963
20964
20965 static PyObject *_wrap_delete_RendererVersion(PyObject *, PyObject *args, PyObject *kwargs) {
20966 PyObject *resultobj;
20967 wxRendererVersion *arg1 = (wxRendererVersion *) 0 ;
20968 PyObject * obj0 = 0 ;
20969 char *kwnames[] = {
20970 (char *) "self", NULL
20971 };
20972
20973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RendererVersion",kwnames,&obj0)) goto fail;
20974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_EXCEPTION | 0);
20975 if (SWIG_arg_fail(1)) SWIG_fail;
20976 {
20977 PyThreadState* __tstate = wxPyBeginAllowThreads();
20978 delete arg1;
20979
20980 wxPyEndAllowThreads(__tstate);
20981 if (PyErr_Occurred()) SWIG_fail;
20982 }
20983 Py_INCREF(Py_None); resultobj = Py_None;
20984 return resultobj;
20985 fail:
20986 return NULL;
20987 }
20988
20989
20990 static PyObject *_wrap_RendererVersion_IsCompatible(PyObject *, PyObject *args, PyObject *kwargs) {
20991 PyObject *resultobj;
20992 wxRendererVersion *arg1 = 0 ;
20993 bool result;
20994 PyObject * obj0 = 0 ;
20995 char *kwnames[] = {
20996 (char *) "ver", NULL
20997 };
20998
20999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererVersion_IsCompatible",kwnames,&obj0)) goto fail;
21000 {
21001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_EXCEPTION | 0);
21002 if (SWIG_arg_fail(1)) SWIG_fail;
21003 if (arg1 == NULL) {
21004 SWIG_null_ref("wxRendererVersion");
21005 }
21006 if (SWIG_arg_fail(1)) SWIG_fail;
21007 }
21008 {
21009 PyThreadState* __tstate = wxPyBeginAllowThreads();
21010 result = (bool)wxRendererVersion::IsCompatible((wxRendererVersion const &)*arg1);
21011
21012 wxPyEndAllowThreads(__tstate);
21013 if (PyErr_Occurred()) SWIG_fail;
21014 }
21015 {
21016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21017 }
21018 return resultobj;
21019 fail:
21020 return NULL;
21021 }
21022
21023
21024 static PyObject *_wrap_RendererVersion_version_get(PyObject *, PyObject *args, PyObject *kwargs) {
21025 PyObject *resultobj;
21026 wxRendererVersion *arg1 = (wxRendererVersion *) 0 ;
21027 int result;
21028 PyObject * obj0 = 0 ;
21029 char *kwnames[] = {
21030 (char *) "self", NULL
21031 };
21032
21033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererVersion_version_get",kwnames,&obj0)) goto fail;
21034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_EXCEPTION | 0);
21035 if (SWIG_arg_fail(1)) SWIG_fail;
21036 result = (int)(int) ((arg1)->version);
21037
21038 {
21039 resultobj = SWIG_From_int((int)(result));
21040 }
21041 return resultobj;
21042 fail:
21043 return NULL;
21044 }
21045
21046
21047 static PyObject *_wrap_RendererVersion_age_get(PyObject *, PyObject *args, PyObject *kwargs) {
21048 PyObject *resultobj;
21049 wxRendererVersion *arg1 = (wxRendererVersion *) 0 ;
21050 int result;
21051 PyObject * obj0 = 0 ;
21052 char *kwnames[] = {
21053 (char *) "self", NULL
21054 };
21055
21056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererVersion_age_get",kwnames,&obj0)) goto fail;
21057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_EXCEPTION | 0);
21058 if (SWIG_arg_fail(1)) SWIG_fail;
21059 result = (int)(int) ((arg1)->age);
21060
21061 {
21062 resultobj = SWIG_From_int((int)(result));
21063 }
21064 return resultobj;
21065 fail:
21066 return NULL;
21067 }
21068
21069
21070 static PyObject * RendererVersion_swigregister(PyObject *, PyObject *args) {
21071 PyObject *obj;
21072 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21073 SWIG_TypeClientData(SWIGTYPE_p_wxRendererVersion, obj);
21074 Py_INCREF(obj);
21075 return Py_BuildValue((char *)"");
21076 }
21077 static PyObject *_wrap_RendererNative_DrawHeaderButton(PyObject *, PyObject *args, PyObject *kwargs) {
21078 PyObject *resultobj;
21079 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21080 wxWindow *arg2 = (wxWindow *) 0 ;
21081 wxDC *arg3 = 0 ;
21082 wxRect *arg4 = 0 ;
21083 int arg5 = (int) 0 ;
21084 wxRect temp4 ;
21085 PyObject * obj0 = 0 ;
21086 PyObject * obj1 = 0 ;
21087 PyObject * obj2 = 0 ;
21088 PyObject * obj3 = 0 ;
21089 PyObject * obj4 = 0 ;
21090 char *kwnames[] = {
21091 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
21092 };
21093
21094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawHeaderButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
21095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21096 if (SWIG_arg_fail(1)) SWIG_fail;
21097 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21098 if (SWIG_arg_fail(2)) SWIG_fail;
21099 {
21100 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21101 if (SWIG_arg_fail(3)) SWIG_fail;
21102 if (arg3 == NULL) {
21103 SWIG_null_ref("wxDC");
21104 }
21105 if (SWIG_arg_fail(3)) SWIG_fail;
21106 }
21107 {
21108 arg4 = &temp4;
21109 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
21110 }
21111 if (obj4) {
21112 {
21113 arg5 = (int)(SWIG_As_int(obj4));
21114 if (SWIG_arg_fail(5)) SWIG_fail;
21115 }
21116 }
21117 {
21118 PyThreadState* __tstate = wxPyBeginAllowThreads();
21119 (arg1)->DrawHeaderButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
21120
21121 wxPyEndAllowThreads(__tstate);
21122 if (PyErr_Occurred()) SWIG_fail;
21123 }
21124 Py_INCREF(Py_None); resultobj = Py_None;
21125 return resultobj;
21126 fail:
21127 return NULL;
21128 }
21129
21130
21131 static PyObject *_wrap_RendererNative_DrawTreeItemButton(PyObject *, PyObject *args, PyObject *kwargs) {
21132 PyObject *resultobj;
21133 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21134 wxWindow *arg2 = (wxWindow *) 0 ;
21135 wxDC *arg3 = 0 ;
21136 wxRect *arg4 = 0 ;
21137 int arg5 = (int) 0 ;
21138 wxRect temp4 ;
21139 PyObject * obj0 = 0 ;
21140 PyObject * obj1 = 0 ;
21141 PyObject * obj2 = 0 ;
21142 PyObject * obj3 = 0 ;
21143 PyObject * obj4 = 0 ;
21144 char *kwnames[] = {
21145 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
21146 };
21147
21148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawTreeItemButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
21149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21150 if (SWIG_arg_fail(1)) SWIG_fail;
21151 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21152 if (SWIG_arg_fail(2)) SWIG_fail;
21153 {
21154 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21155 if (SWIG_arg_fail(3)) SWIG_fail;
21156 if (arg3 == NULL) {
21157 SWIG_null_ref("wxDC");
21158 }
21159 if (SWIG_arg_fail(3)) SWIG_fail;
21160 }
21161 {
21162 arg4 = &temp4;
21163 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
21164 }
21165 if (obj4) {
21166 {
21167 arg5 = (int)(SWIG_As_int(obj4));
21168 if (SWIG_arg_fail(5)) SWIG_fail;
21169 }
21170 }
21171 {
21172 PyThreadState* __tstate = wxPyBeginAllowThreads();
21173 (arg1)->DrawTreeItemButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
21174
21175 wxPyEndAllowThreads(__tstate);
21176 if (PyErr_Occurred()) SWIG_fail;
21177 }
21178 Py_INCREF(Py_None); resultobj = Py_None;
21179 return resultobj;
21180 fail:
21181 return NULL;
21182 }
21183
21184
21185 static PyObject *_wrap_RendererNative_DrawSplitterBorder(PyObject *, PyObject *args, PyObject *kwargs) {
21186 PyObject *resultobj;
21187 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21188 wxWindow *arg2 = (wxWindow *) 0 ;
21189 wxDC *arg3 = 0 ;
21190 wxRect *arg4 = 0 ;
21191 int arg5 = (int) 0 ;
21192 wxRect temp4 ;
21193 PyObject * obj0 = 0 ;
21194 PyObject * obj1 = 0 ;
21195 PyObject * obj2 = 0 ;
21196 PyObject * obj3 = 0 ;
21197 PyObject * obj4 = 0 ;
21198 char *kwnames[] = {
21199 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
21200 };
21201
21202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawSplitterBorder",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
21203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21204 if (SWIG_arg_fail(1)) SWIG_fail;
21205 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21206 if (SWIG_arg_fail(2)) SWIG_fail;
21207 {
21208 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21209 if (SWIG_arg_fail(3)) SWIG_fail;
21210 if (arg3 == NULL) {
21211 SWIG_null_ref("wxDC");
21212 }
21213 if (SWIG_arg_fail(3)) SWIG_fail;
21214 }
21215 {
21216 arg4 = &temp4;
21217 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
21218 }
21219 if (obj4) {
21220 {
21221 arg5 = (int)(SWIG_As_int(obj4));
21222 if (SWIG_arg_fail(5)) SWIG_fail;
21223 }
21224 }
21225 {
21226 PyThreadState* __tstate = wxPyBeginAllowThreads();
21227 (arg1)->DrawSplitterBorder(arg2,*arg3,(wxRect const &)*arg4,arg5);
21228
21229 wxPyEndAllowThreads(__tstate);
21230 if (PyErr_Occurred()) SWIG_fail;
21231 }
21232 Py_INCREF(Py_None); resultobj = Py_None;
21233 return resultobj;
21234 fail:
21235 return NULL;
21236 }
21237
21238
21239 static PyObject *_wrap_RendererNative_DrawSplitterSash(PyObject *, PyObject *args, PyObject *kwargs) {
21240 PyObject *resultobj;
21241 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21242 wxWindow *arg2 = (wxWindow *) 0 ;
21243 wxDC *arg3 = 0 ;
21244 wxSize *arg4 = 0 ;
21245 int arg5 ;
21246 wxOrientation arg6 ;
21247 int arg7 = (int) 0 ;
21248 wxSize temp4 ;
21249 PyObject * obj0 = 0 ;
21250 PyObject * obj1 = 0 ;
21251 PyObject * obj2 = 0 ;
21252 PyObject * obj3 = 0 ;
21253 PyObject * obj4 = 0 ;
21254 PyObject * obj5 = 0 ;
21255 PyObject * obj6 = 0 ;
21256 char *kwnames[] = {
21257 (char *) "self",(char *) "win",(char *) "dc",(char *) "size",(char *) "position",(char *) "orient",(char *) "flags", NULL
21258 };
21259
21260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:RendererNative_DrawSplitterSash",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
21261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21262 if (SWIG_arg_fail(1)) SWIG_fail;
21263 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21264 if (SWIG_arg_fail(2)) SWIG_fail;
21265 {
21266 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21267 if (SWIG_arg_fail(3)) SWIG_fail;
21268 if (arg3 == NULL) {
21269 SWIG_null_ref("wxDC");
21270 }
21271 if (SWIG_arg_fail(3)) SWIG_fail;
21272 }
21273 {
21274 arg4 = &temp4;
21275 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
21276 }
21277 {
21278 arg5 = (int)(SWIG_As_int(obj4));
21279 if (SWIG_arg_fail(5)) SWIG_fail;
21280 }
21281 {
21282 arg6 = (wxOrientation)(SWIG_As_int(obj5));
21283 if (SWIG_arg_fail(6)) SWIG_fail;
21284 }
21285 if (obj6) {
21286 {
21287 arg7 = (int)(SWIG_As_int(obj6));
21288 if (SWIG_arg_fail(7)) SWIG_fail;
21289 }
21290 }
21291 {
21292 PyThreadState* __tstate = wxPyBeginAllowThreads();
21293 (arg1)->DrawSplitterSash(arg2,*arg3,(wxSize const &)*arg4,arg5,(wxOrientation )arg6,arg7);
21294
21295 wxPyEndAllowThreads(__tstate);
21296 if (PyErr_Occurred()) SWIG_fail;
21297 }
21298 Py_INCREF(Py_None); resultobj = Py_None;
21299 return resultobj;
21300 fail:
21301 return NULL;
21302 }
21303
21304
21305 static PyObject *_wrap_RendererNative_DrawComboBoxDropButton(PyObject *, PyObject *args, PyObject *kwargs) {
21306 PyObject *resultobj;
21307 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21308 wxWindow *arg2 = (wxWindow *) 0 ;
21309 wxDC *arg3 = 0 ;
21310 wxRect *arg4 = 0 ;
21311 int arg5 = (int) 0 ;
21312 wxRect temp4 ;
21313 PyObject * obj0 = 0 ;
21314 PyObject * obj1 = 0 ;
21315 PyObject * obj2 = 0 ;
21316 PyObject * obj3 = 0 ;
21317 PyObject * obj4 = 0 ;
21318 char *kwnames[] = {
21319 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
21320 };
21321
21322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawComboBoxDropButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
21323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21324 if (SWIG_arg_fail(1)) SWIG_fail;
21325 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21326 if (SWIG_arg_fail(2)) SWIG_fail;
21327 {
21328 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21329 if (SWIG_arg_fail(3)) SWIG_fail;
21330 if (arg3 == NULL) {
21331 SWIG_null_ref("wxDC");
21332 }
21333 if (SWIG_arg_fail(3)) SWIG_fail;
21334 }
21335 {
21336 arg4 = &temp4;
21337 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
21338 }
21339 if (obj4) {
21340 {
21341 arg5 = (int)(SWIG_As_int(obj4));
21342 if (SWIG_arg_fail(5)) SWIG_fail;
21343 }
21344 }
21345 {
21346 PyThreadState* __tstate = wxPyBeginAllowThreads();
21347 (arg1)->DrawComboBoxDropButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
21348
21349 wxPyEndAllowThreads(__tstate);
21350 if (PyErr_Occurred()) SWIG_fail;
21351 }
21352 Py_INCREF(Py_None); resultobj = Py_None;
21353 return resultobj;
21354 fail:
21355 return NULL;
21356 }
21357
21358
21359 static PyObject *_wrap_RendererNative_DrawDropArrow(PyObject *, PyObject *args, PyObject *kwargs) {
21360 PyObject *resultobj;
21361 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21362 wxWindow *arg2 = (wxWindow *) 0 ;
21363 wxDC *arg3 = 0 ;
21364 wxRect *arg4 = 0 ;
21365 int arg5 = (int) 0 ;
21366 wxRect temp4 ;
21367 PyObject * obj0 = 0 ;
21368 PyObject * obj1 = 0 ;
21369 PyObject * obj2 = 0 ;
21370 PyObject * obj3 = 0 ;
21371 PyObject * obj4 = 0 ;
21372 char *kwnames[] = {
21373 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
21374 };
21375
21376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawDropArrow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
21377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21378 if (SWIG_arg_fail(1)) SWIG_fail;
21379 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21380 if (SWIG_arg_fail(2)) SWIG_fail;
21381 {
21382 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21383 if (SWIG_arg_fail(3)) SWIG_fail;
21384 if (arg3 == NULL) {
21385 SWIG_null_ref("wxDC");
21386 }
21387 if (SWIG_arg_fail(3)) SWIG_fail;
21388 }
21389 {
21390 arg4 = &temp4;
21391 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
21392 }
21393 if (obj4) {
21394 {
21395 arg5 = (int)(SWIG_As_int(obj4));
21396 if (SWIG_arg_fail(5)) SWIG_fail;
21397 }
21398 }
21399 {
21400 PyThreadState* __tstate = wxPyBeginAllowThreads();
21401 (arg1)->DrawDropArrow(arg2,*arg3,(wxRect const &)*arg4,arg5);
21402
21403 wxPyEndAllowThreads(__tstate);
21404 if (PyErr_Occurred()) SWIG_fail;
21405 }
21406 Py_INCREF(Py_None); resultobj = Py_None;
21407 return resultobj;
21408 fail:
21409 return NULL;
21410 }
21411
21412
21413 static PyObject *_wrap_RendererNative_GetSplitterParams(PyObject *, PyObject *args, PyObject *kwargs) {
21414 PyObject *resultobj;
21415 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21416 wxWindow *arg2 = (wxWindow *) 0 ;
21417 SwigValueWrapper<wxSplitterRenderParams > result;
21418 PyObject * obj0 = 0 ;
21419 PyObject * obj1 = 0 ;
21420 char *kwnames[] = {
21421 (char *) "self",(char *) "win", NULL
21422 };
21423
21424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RendererNative_GetSplitterParams",kwnames,&obj0,&obj1)) goto fail;
21425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21426 if (SWIG_arg_fail(1)) SWIG_fail;
21427 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21428 if (SWIG_arg_fail(2)) SWIG_fail;
21429 {
21430 PyThreadState* __tstate = wxPyBeginAllowThreads();
21431 result = (arg1)->GetSplitterParams((wxWindow const *)arg2);
21432
21433 wxPyEndAllowThreads(__tstate);
21434 if (PyErr_Occurred()) SWIG_fail;
21435 }
21436 {
21437 wxSplitterRenderParams * resultptr;
21438 resultptr = new wxSplitterRenderParams((wxSplitterRenderParams &)(result));
21439 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSplitterRenderParams, 1);
21440 }
21441 return resultobj;
21442 fail:
21443 return NULL;
21444 }
21445
21446
21447 static PyObject *_wrap_RendererNative_Get(PyObject *, PyObject *args, PyObject *kwargs) {
21448 PyObject *resultobj;
21449 wxRendererNative *result;
21450 char *kwnames[] = {
21451 NULL
21452 };
21453
21454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":RendererNative_Get",kwnames)) goto fail;
21455 {
21456 PyThreadState* __tstate = wxPyBeginAllowThreads();
21457 {
21458 wxRendererNative &_result_ref = wxRendererNative::Get();
21459 result = (wxRendererNative *) &_result_ref;
21460 }
21461
21462 wxPyEndAllowThreads(__tstate);
21463 if (PyErr_Occurred()) SWIG_fail;
21464 }
21465 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRendererNative, 0);
21466 return resultobj;
21467 fail:
21468 return NULL;
21469 }
21470
21471
21472 static PyObject *_wrap_RendererNative_GetGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
21473 PyObject *resultobj;
21474 wxRendererNative *result;
21475 char *kwnames[] = {
21476 NULL
21477 };
21478
21479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":RendererNative_GetGeneric",kwnames)) goto fail;
21480 {
21481 PyThreadState* __tstate = wxPyBeginAllowThreads();
21482 {
21483 wxRendererNative &_result_ref = wxRendererNative::GetGeneric();
21484 result = (wxRendererNative *) &_result_ref;
21485 }
21486
21487 wxPyEndAllowThreads(__tstate);
21488 if (PyErr_Occurred()) SWIG_fail;
21489 }
21490 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRendererNative, 0);
21491 return resultobj;
21492 fail:
21493 return NULL;
21494 }
21495
21496
21497 static PyObject *_wrap_RendererNative_GetDefault(PyObject *, PyObject *args, PyObject *kwargs) {
21498 PyObject *resultobj;
21499 wxRendererNative *result;
21500 char *kwnames[] = {
21501 NULL
21502 };
21503
21504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":RendererNative_GetDefault",kwnames)) goto fail;
21505 {
21506 PyThreadState* __tstate = wxPyBeginAllowThreads();
21507 {
21508 wxRendererNative &_result_ref = wxRendererNative::GetDefault();
21509 result = (wxRendererNative *) &_result_ref;
21510 }
21511
21512 wxPyEndAllowThreads(__tstate);
21513 if (PyErr_Occurred()) SWIG_fail;
21514 }
21515 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRendererNative, 0);
21516 return resultobj;
21517 fail:
21518 return NULL;
21519 }
21520
21521
21522 static PyObject *_wrap_RendererNative_Set(PyObject *, PyObject *args, PyObject *kwargs) {
21523 PyObject *resultobj;
21524 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21525 wxRendererNative *result;
21526 PyObject * obj0 = 0 ;
21527 char *kwnames[] = {
21528 (char *) "renderer", NULL
21529 };
21530
21531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererNative_Set",kwnames,&obj0)) goto fail;
21532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21533 if (SWIG_arg_fail(1)) SWIG_fail;
21534 {
21535 PyThreadState* __tstate = wxPyBeginAllowThreads();
21536 result = (wxRendererNative *)wxRendererNative::Set(arg1);
21537
21538 wxPyEndAllowThreads(__tstate);
21539 if (PyErr_Occurred()) SWIG_fail;
21540 }
21541 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRendererNative, 0);
21542 return resultobj;
21543 fail:
21544 return NULL;
21545 }
21546
21547
21548 static PyObject *_wrap_RendererNative_GetVersion(PyObject *, PyObject *args, PyObject *kwargs) {
21549 PyObject *resultobj;
21550 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21551 SwigValueWrapper<wxRendererVersion > result;
21552 PyObject * obj0 = 0 ;
21553 char *kwnames[] = {
21554 (char *) "self", NULL
21555 };
21556
21557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererNative_GetVersion",kwnames,&obj0)) goto fail;
21558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21559 if (SWIG_arg_fail(1)) SWIG_fail;
21560 {
21561 PyThreadState* __tstate = wxPyBeginAllowThreads();
21562 result = ((wxRendererNative const *)arg1)->GetVersion();
21563
21564 wxPyEndAllowThreads(__tstate);
21565 if (PyErr_Occurred()) SWIG_fail;
21566 }
21567 {
21568 wxRendererVersion * resultptr;
21569 resultptr = new wxRendererVersion((wxRendererVersion &)(result));
21570 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRendererVersion, 1);
21571 }
21572 return resultobj;
21573 fail:
21574 return NULL;
21575 }
21576
21577
21578 static PyObject * RendererNative_swigregister(PyObject *, PyObject *args) {
21579 PyObject *obj;
21580 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21581 SWIG_TypeClientData(SWIGTYPE_p_wxRendererNative, obj);
21582 Py_INCREF(obj);
21583 return Py_BuildValue((char *)"");
21584 }
21585 static PyMethodDef SwigMethods[] = {
21586 { (char *)"new_GDIObject", (PyCFunction) _wrap_new_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
21587 { (char *)"delete_GDIObject", (PyCFunction) _wrap_delete_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
21588 { (char *)"GDIObject_GetVisible", (PyCFunction) _wrap_GDIObject_GetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
21589 { (char *)"GDIObject_SetVisible", (PyCFunction) _wrap_GDIObject_SetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
21590 { (char *)"GDIObject_IsNull", (PyCFunction) _wrap_GDIObject_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
21591 { (char *)"GDIObject_swigregister", GDIObject_swigregister, METH_VARARGS, NULL},
21592 { (char *)"new_Colour", (PyCFunction) _wrap_new_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
21593 { (char *)"new_NamedColour", (PyCFunction) _wrap_new_NamedColour, METH_VARARGS | METH_KEYWORDS, NULL},
21594 { (char *)"new_ColourRGB", (PyCFunction) _wrap_new_ColourRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21595 { (char *)"delete_Colour", (PyCFunction) _wrap_delete_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
21596 { (char *)"Colour_Red", (PyCFunction) _wrap_Colour_Red, METH_VARARGS | METH_KEYWORDS, NULL},
21597 { (char *)"Colour_Green", (PyCFunction) _wrap_Colour_Green, METH_VARARGS | METH_KEYWORDS, NULL},
21598 { (char *)"Colour_Blue", (PyCFunction) _wrap_Colour_Blue, METH_VARARGS | METH_KEYWORDS, NULL},
21599 { (char *)"Colour_Ok", (PyCFunction) _wrap_Colour_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21600 { (char *)"Colour_Set", (PyCFunction) _wrap_Colour_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21601 { (char *)"Colour_SetRGB", (PyCFunction) _wrap_Colour_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21602 { (char *)"Colour_SetFromName", (PyCFunction) _wrap_Colour_SetFromName, METH_VARARGS | METH_KEYWORDS, NULL},
21603 { (char *)"Colour_GetPixel", (PyCFunction) _wrap_Colour_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
21604 { (char *)"Colour___eq__", (PyCFunction) _wrap_Colour___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21605 { (char *)"Colour___ne__", (PyCFunction) _wrap_Colour___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21606 { (char *)"Colour_Get", (PyCFunction) _wrap_Colour_Get, METH_VARARGS | METH_KEYWORDS, NULL},
21607 { (char *)"Colour_GetRGB", (PyCFunction) _wrap_Colour_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21608 { (char *)"Colour_swigregister", Colour_swigregister, METH_VARARGS, NULL},
21609 { (char *)"new_Palette", (PyCFunction) _wrap_new_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
21610 { (char *)"delete_Palette", (PyCFunction) _wrap_delete_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
21611 { (char *)"Palette_GetPixel", (PyCFunction) _wrap_Palette_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
21612 { (char *)"Palette_GetRGB", (PyCFunction) _wrap_Palette_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21613 { (char *)"Palette_GetColoursCount", (PyCFunction) _wrap_Palette_GetColoursCount, METH_VARARGS | METH_KEYWORDS, NULL},
21614 { (char *)"Palette_Ok", (PyCFunction) _wrap_Palette_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21615 { (char *)"Palette_swigregister", Palette_swigregister, METH_VARARGS, NULL},
21616 { (char *)"new_Pen", (PyCFunction) _wrap_new_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
21617 { (char *)"delete_Pen", (PyCFunction) _wrap_delete_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
21618 { (char *)"Pen_GetCap", (PyCFunction) _wrap_Pen_GetCap, METH_VARARGS | METH_KEYWORDS, NULL},
21619 { (char *)"Pen_GetColour", (PyCFunction) _wrap_Pen_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21620 { (char *)"Pen_GetJoin", (PyCFunction) _wrap_Pen_GetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
21621 { (char *)"Pen_GetStyle", (PyCFunction) _wrap_Pen_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21622 { (char *)"Pen_GetWidth", (PyCFunction) _wrap_Pen_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21623 { (char *)"Pen_Ok", (PyCFunction) _wrap_Pen_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21624 { (char *)"Pen_SetCap", (PyCFunction) _wrap_Pen_SetCap, METH_VARARGS | METH_KEYWORDS, NULL},
21625 { (char *)"Pen_SetColour", (PyCFunction) _wrap_Pen_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21626 { (char *)"Pen_SetJoin", (PyCFunction) _wrap_Pen_SetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
21627 { (char *)"Pen_SetStyle", (PyCFunction) _wrap_Pen_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21628 { (char *)"Pen_SetWidth", (PyCFunction) _wrap_Pen_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21629 { (char *)"Pen_SetDashes", (PyCFunction) _wrap_Pen_SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
21630 { (char *)"Pen_GetDashes", (PyCFunction) _wrap_Pen_GetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
21631 { (char *)"Pen__SetDashes", (PyCFunction) _wrap_Pen__SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
21632 { (char *)"Pen___eq__", (PyCFunction) _wrap_Pen___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21633 { (char *)"Pen___ne__", (PyCFunction) _wrap_Pen___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21634 { (char *)"Pen_swigregister", Pen_swigregister, METH_VARARGS, NULL},
21635 { (char *)"new_Brush", (PyCFunction) _wrap_new_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
21636 { (char *)"new_BrushFromBitmap", (PyCFunction) _wrap_new_BrushFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21637 { (char *)"delete_Brush", (PyCFunction) _wrap_delete_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
21638 { (char *)"Brush_SetColour", (PyCFunction) _wrap_Brush_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21639 { (char *)"Brush_SetStyle", (PyCFunction) _wrap_Brush_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21640 { (char *)"Brush_SetStipple", (PyCFunction) _wrap_Brush_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
21641 { (char *)"Brush_GetColour", (PyCFunction) _wrap_Brush_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21642 { (char *)"Brush_GetStyle", (PyCFunction) _wrap_Brush_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21643 { (char *)"Brush_GetStipple", (PyCFunction) _wrap_Brush_GetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
21644 { (char *)"Brush_IsHatch", (PyCFunction) _wrap_Brush_IsHatch, METH_VARARGS | METH_KEYWORDS, NULL},
21645 { (char *)"Brush_Ok", (PyCFunction) _wrap_Brush_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21646 { (char *)"Brush_MacGetTheme", (PyCFunction) _wrap_Brush_MacGetTheme, METH_VARARGS | METH_KEYWORDS, NULL},
21647 { (char *)"Brush_MacSetTheme", (PyCFunction) _wrap_Brush_MacSetTheme, METH_VARARGS | METH_KEYWORDS, NULL},
21648 { (char *)"Brush_swigregister", Brush_swigregister, METH_VARARGS, NULL},
21649 { (char *)"new_Bitmap", (PyCFunction) _wrap_new_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21650 { (char *)"delete_Bitmap", (PyCFunction) _wrap_delete_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21651 { (char *)"new_EmptyBitmap", (PyCFunction) _wrap_new_EmptyBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21652 { (char *)"new_BitmapFromIcon", (PyCFunction) _wrap_new_BitmapFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21653 { (char *)"new_BitmapFromImage", (PyCFunction) _wrap_new_BitmapFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
21654 { (char *)"new_BitmapFromXPMData", (PyCFunction) _wrap_new_BitmapFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
21655 { (char *)"new_BitmapFromBits", (PyCFunction) _wrap_new_BitmapFromBits, METH_VARARGS | METH_KEYWORDS, NULL},
21656 { (char *)"Bitmap_Ok", (PyCFunction) _wrap_Bitmap_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21657 { (char *)"Bitmap_GetWidth", (PyCFunction) _wrap_Bitmap_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21658 { (char *)"Bitmap_GetHeight", (PyCFunction) _wrap_Bitmap_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21659 { (char *)"Bitmap_GetDepth", (PyCFunction) _wrap_Bitmap_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21660 { (char *)"Bitmap_GetSize", (PyCFunction) _wrap_Bitmap_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21661 { (char *)"Bitmap_ConvertToImage", (PyCFunction) _wrap_Bitmap_ConvertToImage, METH_VARARGS | METH_KEYWORDS, NULL},
21662 { (char *)"Bitmap_GetMask", (PyCFunction) _wrap_Bitmap_GetMask, METH_VARARGS | METH_KEYWORDS, NULL},
21663 { (char *)"Bitmap_SetMask", (PyCFunction) _wrap_Bitmap_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
21664 { (char *)"Bitmap_SetMaskColour", (PyCFunction) _wrap_Bitmap_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
21665 { (char *)"Bitmap_GetSubBitmap", (PyCFunction) _wrap_Bitmap_GetSubBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21666 { (char *)"Bitmap_SaveFile", (PyCFunction) _wrap_Bitmap_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
21667 { (char *)"Bitmap_LoadFile", (PyCFunction) _wrap_Bitmap_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
21668 { (char *)"Bitmap_GetPalette", (PyCFunction) _wrap_Bitmap_GetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
21669 { (char *)"Bitmap_CopyFromIcon", (PyCFunction) _wrap_Bitmap_CopyFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21670 { (char *)"Bitmap_SetHeight", (PyCFunction) _wrap_Bitmap_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21671 { (char *)"Bitmap_SetWidth", (PyCFunction) _wrap_Bitmap_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21672 { (char *)"Bitmap_SetDepth", (PyCFunction) _wrap_Bitmap_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21673 { (char *)"Bitmap_SetSize", (PyCFunction) _wrap_Bitmap_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21674 { (char *)"Bitmap___eq__", (PyCFunction) _wrap_Bitmap___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21675 { (char *)"Bitmap___ne__", (PyCFunction) _wrap_Bitmap___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21676 { (char *)"Bitmap_swigregister", Bitmap_swigregister, METH_VARARGS, NULL},
21677 { (char *)"new_Mask", (PyCFunction) _wrap_new_Mask, METH_VARARGS | METH_KEYWORDS, NULL},
21678 { (char *)"Mask_swigregister", Mask_swigregister, METH_VARARGS, NULL},
21679 { (char *)"new_Icon", (PyCFunction) _wrap_new_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
21680 { (char *)"delete_Icon", (PyCFunction) _wrap_delete_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
21681 { (char *)"new_EmptyIcon", (PyCFunction) _wrap_new_EmptyIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21682 { (char *)"new_IconFromLocation", (PyCFunction) _wrap_new_IconFromLocation, METH_VARARGS | METH_KEYWORDS, NULL},
21683 { (char *)"new_IconFromBitmap", (PyCFunction) _wrap_new_IconFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21684 { (char *)"new_IconFromXPMData", (PyCFunction) _wrap_new_IconFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
21685 { (char *)"Icon_Ok", (PyCFunction) _wrap_Icon_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21686 { (char *)"Icon_GetWidth", (PyCFunction) _wrap_Icon_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21687 { (char *)"Icon_GetHeight", (PyCFunction) _wrap_Icon_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21688 { (char *)"Icon_GetDepth", (PyCFunction) _wrap_Icon_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21689 { (char *)"Icon_SetWidth", (PyCFunction) _wrap_Icon_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21690 { (char *)"Icon_SetHeight", (PyCFunction) _wrap_Icon_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21691 { (char *)"Icon_SetDepth", (PyCFunction) _wrap_Icon_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21692 { (char *)"Icon_CopyFromBitmap", (PyCFunction) _wrap_Icon_CopyFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21693 { (char *)"Icon_swigregister", Icon_swigregister, METH_VARARGS, NULL},
21694 { (char *)"new_IconLocation", (PyCFunction) _wrap_new_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
21695 { (char *)"delete_IconLocation", (PyCFunction) _wrap_delete_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
21696 { (char *)"IconLocation_IsOk", (PyCFunction) _wrap_IconLocation_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
21697 { (char *)"IconLocation_SetFileName", (PyCFunction) _wrap_IconLocation_SetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
21698 { (char *)"IconLocation_GetFileName", (PyCFunction) _wrap_IconLocation_GetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
21699 { (char *)"IconLocation_SetIndex", (PyCFunction) _wrap_IconLocation_SetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
21700 { (char *)"IconLocation_GetIndex", (PyCFunction) _wrap_IconLocation_GetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
21701 { (char *)"IconLocation_swigregister", IconLocation_swigregister, METH_VARARGS, NULL},
21702 { (char *)"new_IconBundle", (PyCFunction) _wrap_new_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
21703 { (char *)"new_IconBundleFromFile", (PyCFunction) _wrap_new_IconBundleFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
21704 { (char *)"new_IconBundleFromIcon", (PyCFunction) _wrap_new_IconBundleFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21705 { (char *)"delete_IconBundle", (PyCFunction) _wrap_delete_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
21706 { (char *)"IconBundle_AddIcon", (PyCFunction) _wrap_IconBundle_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21707 { (char *)"IconBundle_AddIconFromFile", (PyCFunction) _wrap_IconBundle_AddIconFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
21708 { (char *)"IconBundle_GetIcon", (PyCFunction) _wrap_IconBundle_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21709 { (char *)"IconBundle_swigregister", IconBundle_swigregister, METH_VARARGS, NULL},
21710 { (char *)"new_Cursor", (PyCFunction) _wrap_new_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
21711 { (char *)"delete_Cursor", (PyCFunction) _wrap_delete_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
21712 { (char *)"new_StockCursor", (PyCFunction) _wrap_new_StockCursor, METH_VARARGS | METH_KEYWORDS, NULL},
21713 { (char *)"new_CursorFromImage", (PyCFunction) _wrap_new_CursorFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
21714 { (char *)"Cursor_Ok", (PyCFunction) _wrap_Cursor_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21715 { (char *)"Cursor_swigregister", Cursor_swigregister, METH_VARARGS, NULL},
21716 { (char *)"new_Region", (PyCFunction) _wrap_new_Region, METH_VARARGS | METH_KEYWORDS, NULL},
21717 { (char *)"new_RegionFromBitmap", (PyCFunction) _wrap_new_RegionFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21718 { (char *)"new_RegionFromBitmapColour", (PyCFunction) _wrap_new_RegionFromBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
21719 { (char *)"new_RegionFromPoints", (PyCFunction) _wrap_new_RegionFromPoints, METH_VARARGS | METH_KEYWORDS, NULL},
21720 { (char *)"delete_Region", (PyCFunction) _wrap_delete_Region, METH_VARARGS | METH_KEYWORDS, NULL},
21721 { (char *)"Region_Clear", (PyCFunction) _wrap_Region_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
21722 { (char *)"Region_Offset", (PyCFunction) _wrap_Region_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
21723 { (char *)"Region_Contains", (PyCFunction) _wrap_Region_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
21724 { (char *)"Region_ContainsPoint", (PyCFunction) _wrap_Region_ContainsPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21725 { (char *)"Region_ContainsRect", (PyCFunction) _wrap_Region_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
21726 { (char *)"Region_ContainsRectDim", (PyCFunction) _wrap_Region_ContainsRectDim, METH_VARARGS | METH_KEYWORDS, NULL},
21727 { (char *)"Region_GetBox", (PyCFunction) _wrap_Region_GetBox, METH_VARARGS | METH_KEYWORDS, NULL},
21728 { (char *)"Region_Intersect", (PyCFunction) _wrap_Region_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
21729 { (char *)"Region_IntersectRect", (PyCFunction) _wrap_Region_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
21730 { (char *)"Region_IntersectRegion", (PyCFunction) _wrap_Region_IntersectRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21731 { (char *)"Region_IsEmpty", (PyCFunction) _wrap_Region_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
21732 { (char *)"Region_Union", (PyCFunction) _wrap_Region_Union, METH_VARARGS | METH_KEYWORDS, NULL},
21733 { (char *)"Region_UnionRect", (PyCFunction) _wrap_Region_UnionRect, METH_VARARGS | METH_KEYWORDS, NULL},
21734 { (char *)"Region_UnionRegion", (PyCFunction) _wrap_Region_UnionRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21735 { (char *)"Region_Subtract", (PyCFunction) _wrap_Region_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
21736 { (char *)"Region_SubtractRect", (PyCFunction) _wrap_Region_SubtractRect, METH_VARARGS | METH_KEYWORDS, NULL},
21737 { (char *)"Region_SubtractRegion", (PyCFunction) _wrap_Region_SubtractRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21738 { (char *)"Region_Xor", (PyCFunction) _wrap_Region_Xor, METH_VARARGS | METH_KEYWORDS, NULL},
21739 { (char *)"Region_XorRect", (PyCFunction) _wrap_Region_XorRect, METH_VARARGS | METH_KEYWORDS, NULL},
21740 { (char *)"Region_XorRegion", (PyCFunction) _wrap_Region_XorRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21741 { (char *)"Region_ConvertToBitmap", (PyCFunction) _wrap_Region_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21742 { (char *)"Region_UnionBitmap", (PyCFunction) _wrap_Region_UnionBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21743 { (char *)"Region_UnionBitmapColour", (PyCFunction) _wrap_Region_UnionBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
21744 { (char *)"Region_swigregister", Region_swigregister, METH_VARARGS, NULL},
21745 { (char *)"new_RegionIterator", (PyCFunction) _wrap_new_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
21746 { (char *)"delete_RegionIterator", (PyCFunction) _wrap_delete_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
21747 { (char *)"RegionIterator_GetX", (PyCFunction) _wrap_RegionIterator_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
21748 { (char *)"RegionIterator_GetY", (PyCFunction) _wrap_RegionIterator_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
21749 { (char *)"RegionIterator_GetW", (PyCFunction) _wrap_RegionIterator_GetW, METH_VARARGS | METH_KEYWORDS, NULL},
21750 { (char *)"RegionIterator_GetWidth", (PyCFunction) _wrap_RegionIterator_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21751 { (char *)"RegionIterator_GetH", (PyCFunction) _wrap_RegionIterator_GetH, METH_VARARGS | METH_KEYWORDS, NULL},
21752 { (char *)"RegionIterator_GetHeight", (PyCFunction) _wrap_RegionIterator_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21753 { (char *)"RegionIterator_GetRect", (PyCFunction) _wrap_RegionIterator_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
21754 { (char *)"RegionIterator_HaveRects", (PyCFunction) _wrap_RegionIterator_HaveRects, METH_VARARGS | METH_KEYWORDS, NULL},
21755 { (char *)"RegionIterator_Reset", (PyCFunction) _wrap_RegionIterator_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
21756 { (char *)"RegionIterator_Next", (PyCFunction) _wrap_RegionIterator_Next, METH_VARARGS | METH_KEYWORDS, NULL},
21757 { (char *)"RegionIterator___nonzero__", (PyCFunction) _wrap_RegionIterator___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
21758 { (char *)"RegionIterator_swigregister", RegionIterator_swigregister, METH_VARARGS, NULL},
21759 { (char *)"new_NativeFontInfo", (PyCFunction) _wrap_new_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21760 { (char *)"delete_NativeFontInfo", (PyCFunction) _wrap_delete_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21761 { (char *)"NativeFontInfo_Init", (PyCFunction) _wrap_NativeFontInfo_Init, METH_VARARGS | METH_KEYWORDS, NULL},
21762 { (char *)"NativeFontInfo_InitFromFont", (PyCFunction) _wrap_NativeFontInfo_InitFromFont, METH_VARARGS | METH_KEYWORDS, NULL},
21763 { (char *)"NativeFontInfo_GetPointSize", (PyCFunction) _wrap_NativeFontInfo_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21764 { (char *)"NativeFontInfo_GetStyle", (PyCFunction) _wrap_NativeFontInfo_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21765 { (char *)"NativeFontInfo_GetWeight", (PyCFunction) _wrap_NativeFontInfo_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21766 { (char *)"NativeFontInfo_GetUnderlined", (PyCFunction) _wrap_NativeFontInfo_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21767 { (char *)"NativeFontInfo_GetFaceName", (PyCFunction) _wrap_NativeFontInfo_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21768 { (char *)"NativeFontInfo_GetFamily", (PyCFunction) _wrap_NativeFontInfo_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21769 { (char *)"NativeFontInfo_GetEncoding", (PyCFunction) _wrap_NativeFontInfo_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21770 { (char *)"NativeFontInfo_SetPointSize", (PyCFunction) _wrap_NativeFontInfo_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21771 { (char *)"NativeFontInfo_SetStyle", (PyCFunction) _wrap_NativeFontInfo_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21772 { (char *)"NativeFontInfo_SetWeight", (PyCFunction) _wrap_NativeFontInfo_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21773 { (char *)"NativeFontInfo_SetUnderlined", (PyCFunction) _wrap_NativeFontInfo_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21774 { (char *)"NativeFontInfo_SetFaceName", (PyCFunction) _wrap_NativeFontInfo_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21775 { (char *)"NativeFontInfo_SetFamily", (PyCFunction) _wrap_NativeFontInfo_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21776 { (char *)"NativeFontInfo_SetEncoding", (PyCFunction) _wrap_NativeFontInfo_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21777 { (char *)"NativeFontInfo_FromString", (PyCFunction) _wrap_NativeFontInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
21778 { (char *)"NativeFontInfo_ToString", (PyCFunction) _wrap_NativeFontInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
21779 { (char *)"NativeFontInfo___str__", (PyCFunction) _wrap_NativeFontInfo___str__, METH_VARARGS | METH_KEYWORDS, NULL},
21780 { (char *)"NativeFontInfo_FromUserString", (PyCFunction) _wrap_NativeFontInfo_FromUserString, METH_VARARGS | METH_KEYWORDS, NULL},
21781 { (char *)"NativeFontInfo_ToUserString", (PyCFunction) _wrap_NativeFontInfo_ToUserString, METH_VARARGS | METH_KEYWORDS, NULL},
21782 { (char *)"NativeFontInfo_swigregister", NativeFontInfo_swigregister, METH_VARARGS, NULL},
21783 { (char *)"NativeEncodingInfo_facename_set", (PyCFunction) _wrap_NativeEncodingInfo_facename_set, METH_VARARGS | METH_KEYWORDS, NULL},
21784 { (char *)"NativeEncodingInfo_facename_get", (PyCFunction) _wrap_NativeEncodingInfo_facename_get, METH_VARARGS | METH_KEYWORDS, NULL},
21785 { (char *)"NativeEncodingInfo_encoding_set", (PyCFunction) _wrap_NativeEncodingInfo_encoding_set, METH_VARARGS | METH_KEYWORDS, NULL},
21786 { (char *)"NativeEncodingInfo_encoding_get", (PyCFunction) _wrap_NativeEncodingInfo_encoding_get, METH_VARARGS | METH_KEYWORDS, NULL},
21787 { (char *)"new_NativeEncodingInfo", (PyCFunction) _wrap_new_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21788 { (char *)"delete_NativeEncodingInfo", (PyCFunction) _wrap_delete_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21789 { (char *)"NativeEncodingInfo_FromString", (PyCFunction) _wrap_NativeEncodingInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
21790 { (char *)"NativeEncodingInfo_ToString", (PyCFunction) _wrap_NativeEncodingInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
21791 { (char *)"NativeEncodingInfo_swigregister", NativeEncodingInfo_swigregister, METH_VARARGS, NULL},
21792 { (char *)"GetNativeFontEncoding", (PyCFunction) _wrap_GetNativeFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21793 { (char *)"TestFontEncoding", (PyCFunction) _wrap_TestFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21794 { (char *)"new_FontMapper", (PyCFunction) _wrap_new_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
21795 { (char *)"delete_FontMapper", (PyCFunction) _wrap_delete_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
21796 { (char *)"FontMapper_Get", (PyCFunction) _wrap_FontMapper_Get, METH_VARARGS | METH_KEYWORDS, NULL},
21797 { (char *)"FontMapper_Set", (PyCFunction) _wrap_FontMapper_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21798 { (char *)"FontMapper_CharsetToEncoding", (PyCFunction) _wrap_FontMapper_CharsetToEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21799 { (char *)"FontMapper_GetSupportedEncodingsCount", (PyCFunction) _wrap_FontMapper_GetSupportedEncodingsCount, METH_VARARGS | METH_KEYWORDS, NULL},
21800 { (char *)"FontMapper_GetEncoding", (PyCFunction) _wrap_FontMapper_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21801 { (char *)"FontMapper_GetEncodingName", (PyCFunction) _wrap_FontMapper_GetEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
21802 { (char *)"FontMapper_GetEncodingDescription", (PyCFunction) _wrap_FontMapper_GetEncodingDescription, METH_VARARGS | METH_KEYWORDS, NULL},
21803 { (char *)"FontMapper_GetEncodingFromName", (PyCFunction) _wrap_FontMapper_GetEncodingFromName, METH_VARARGS | METH_KEYWORDS, NULL},
21804 { (char *)"FontMapper_SetConfigPath", (PyCFunction) _wrap_FontMapper_SetConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
21805 { (char *)"FontMapper_GetDefaultConfigPath", (PyCFunction) _wrap_FontMapper_GetDefaultConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
21806 { (char *)"FontMapper_GetAltForEncoding", (PyCFunction) _wrap_FontMapper_GetAltForEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21807 { (char *)"FontMapper_IsEncodingAvailable", (PyCFunction) _wrap_FontMapper_IsEncodingAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
21808 { (char *)"FontMapper_SetDialogParent", (PyCFunction) _wrap_FontMapper_SetDialogParent, METH_VARARGS | METH_KEYWORDS, NULL},
21809 { (char *)"FontMapper_SetDialogTitle", (PyCFunction) _wrap_FontMapper_SetDialogTitle, METH_VARARGS | METH_KEYWORDS, NULL},
21810 { (char *)"FontMapper_swigregister", FontMapper_swigregister, METH_VARARGS, NULL},
21811 { (char *)"new_Font", (PyCFunction) _wrap_new_Font, METH_VARARGS | METH_KEYWORDS, NULL},
21812 { (char *)"delete_Font", (PyCFunction) _wrap_delete_Font, METH_VARARGS | METH_KEYWORDS, NULL},
21813 { (char *)"new_FontFromNativeInfo", (PyCFunction) _wrap_new_FontFromNativeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21814 { (char *)"new_FontFromNativeInfoString", (PyCFunction) _wrap_new_FontFromNativeInfoString, METH_VARARGS | METH_KEYWORDS, NULL},
21815 { (char *)"new_FFont", (PyCFunction) _wrap_new_FFont, METH_VARARGS | METH_KEYWORDS, NULL},
21816 { (char *)"new_FontFromPixelSize", (PyCFunction) _wrap_new_FontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21817 { (char *)"new_FFontFromPixelSize", (PyCFunction) _wrap_new_FFontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21818 { (char *)"Font_Ok", (PyCFunction) _wrap_Font_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21819 { (char *)"Font___eq__", (PyCFunction) _wrap_Font___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21820 { (char *)"Font___ne__", (PyCFunction) _wrap_Font___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21821 { (char *)"Font_GetPointSize", (PyCFunction) _wrap_Font_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21822 { (char *)"Font_GetPixelSize", (PyCFunction) _wrap_Font_GetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21823 { (char *)"Font_IsUsingSizeInPixels", (PyCFunction) _wrap_Font_IsUsingSizeInPixels, METH_VARARGS | METH_KEYWORDS, NULL},
21824 { (char *)"Font_GetFamily", (PyCFunction) _wrap_Font_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21825 { (char *)"Font_GetStyle", (PyCFunction) _wrap_Font_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21826 { (char *)"Font_GetWeight", (PyCFunction) _wrap_Font_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21827 { (char *)"Font_GetUnderlined", (PyCFunction) _wrap_Font_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21828 { (char *)"Font_GetFaceName", (PyCFunction) _wrap_Font_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21829 { (char *)"Font_GetEncoding", (PyCFunction) _wrap_Font_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21830 { (char *)"Font_GetNativeFontInfo", (PyCFunction) _wrap_Font_GetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21831 { (char *)"Font_IsFixedWidth", (PyCFunction) _wrap_Font_IsFixedWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21832 { (char *)"Font_GetNativeFontInfoDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoDesc, METH_VARARGS | METH_KEYWORDS, NULL},
21833 { (char *)"Font_GetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
21834 { (char *)"Font_SetPointSize", (PyCFunction) _wrap_Font_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21835 { (char *)"Font_SetPixelSize", (PyCFunction) _wrap_Font_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21836 { (char *)"Font_SetFamily", (PyCFunction) _wrap_Font_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21837 { (char *)"Font_SetStyle", (PyCFunction) _wrap_Font_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21838 { (char *)"Font_SetWeight", (PyCFunction) _wrap_Font_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21839 { (char *)"Font_SetFaceName", (PyCFunction) _wrap_Font_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21840 { (char *)"Font_SetUnderlined", (PyCFunction) _wrap_Font_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21841 { (char *)"Font_SetEncoding", (PyCFunction) _wrap_Font_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21842 { (char *)"Font_SetNativeFontInfo", (PyCFunction) _wrap_Font_SetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21843 { (char *)"Font_SetNativeFontInfoFromString", (PyCFunction) _wrap_Font_SetNativeFontInfoFromString, METH_VARARGS | METH_KEYWORDS, NULL},
21844 { (char *)"Font_SetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_SetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
21845 { (char *)"Font_GetFamilyString", (PyCFunction) _wrap_Font_GetFamilyString, METH_VARARGS | METH_KEYWORDS, NULL},
21846 { (char *)"Font_GetStyleString", (PyCFunction) _wrap_Font_GetStyleString, METH_VARARGS | METH_KEYWORDS, NULL},
21847 { (char *)"Font_GetWeightString", (PyCFunction) _wrap_Font_GetWeightString, METH_VARARGS | METH_KEYWORDS, NULL},
21848 { (char *)"Font_SetNoAntiAliasing", (PyCFunction) _wrap_Font_SetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
21849 { (char *)"Font_GetNoAntiAliasing", (PyCFunction) _wrap_Font_GetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
21850 { (char *)"Font_GetDefaultEncoding", (PyCFunction) _wrap_Font_GetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21851 { (char *)"Font_SetDefaultEncoding", (PyCFunction) _wrap_Font_SetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21852 { (char *)"Font_swigregister", Font_swigregister, METH_VARARGS, NULL},
21853 { (char *)"new_FontEnumerator", (PyCFunction) _wrap_new_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
21854 { (char *)"delete_FontEnumerator", (PyCFunction) _wrap_delete_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
21855 { (char *)"FontEnumerator__setCallbackInfo", (PyCFunction) _wrap_FontEnumerator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21856 { (char *)"FontEnumerator_EnumerateFacenames", (PyCFunction) _wrap_FontEnumerator_EnumerateFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
21857 { (char *)"FontEnumerator_EnumerateEncodings", (PyCFunction) _wrap_FontEnumerator_EnumerateEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
21858 { (char *)"FontEnumerator_GetEncodings", (PyCFunction) _wrap_FontEnumerator_GetEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
21859 { (char *)"FontEnumerator_GetFacenames", (PyCFunction) _wrap_FontEnumerator_GetFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
21860 { (char *)"FontEnumerator_swigregister", FontEnumerator_swigregister, METH_VARARGS, NULL},
21861 { (char *)"LanguageInfo_Language_set", (PyCFunction) _wrap_LanguageInfo_Language_set, METH_VARARGS | METH_KEYWORDS, NULL},
21862 { (char *)"LanguageInfo_Language_get", (PyCFunction) _wrap_LanguageInfo_Language_get, METH_VARARGS | METH_KEYWORDS, NULL},
21863 { (char *)"LanguageInfo_CanonicalName_set", (PyCFunction) _wrap_LanguageInfo_CanonicalName_set, METH_VARARGS | METH_KEYWORDS, NULL},
21864 { (char *)"LanguageInfo_CanonicalName_get", (PyCFunction) _wrap_LanguageInfo_CanonicalName_get, METH_VARARGS | METH_KEYWORDS, NULL},
21865 { (char *)"LanguageInfo_Description_set", (PyCFunction) _wrap_LanguageInfo_Description_set, METH_VARARGS | METH_KEYWORDS, NULL},
21866 { (char *)"LanguageInfo_Description_get", (PyCFunction) _wrap_LanguageInfo_Description_get, METH_VARARGS | METH_KEYWORDS, NULL},
21867 { (char *)"LanguageInfo_swigregister", LanguageInfo_swigregister, METH_VARARGS, NULL},
21868 { (char *)"new_Locale", (PyCFunction) _wrap_new_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
21869 { (char *)"delete_Locale", (PyCFunction) _wrap_delete_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
21870 { (char *)"Locale_Init1", (PyCFunction) _wrap_Locale_Init1, METH_VARARGS | METH_KEYWORDS, NULL},
21871 { (char *)"Locale_Init2", (PyCFunction) _wrap_Locale_Init2, METH_VARARGS | METH_KEYWORDS, NULL},
21872 { (char *)"Locale_GetSystemLanguage", (PyCFunction) _wrap_Locale_GetSystemLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
21873 { (char *)"Locale_GetSystemEncoding", (PyCFunction) _wrap_Locale_GetSystemEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21874 { (char *)"Locale_GetSystemEncodingName", (PyCFunction) _wrap_Locale_GetSystemEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
21875 { (char *)"Locale_IsOk", (PyCFunction) _wrap_Locale_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
21876 { (char *)"Locale_GetLocale", (PyCFunction) _wrap_Locale_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
21877 { (char *)"Locale_GetLanguage", (PyCFunction) _wrap_Locale_GetLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
21878 { (char *)"Locale_GetSysName", (PyCFunction) _wrap_Locale_GetSysName, METH_VARARGS | METH_KEYWORDS, NULL},
21879 { (char *)"Locale_GetCanonicalName", (PyCFunction) _wrap_Locale_GetCanonicalName, METH_VARARGS | METH_KEYWORDS, NULL},
21880 { (char *)"Locale_AddCatalogLookupPathPrefix", (PyCFunction) _wrap_Locale_AddCatalogLookupPathPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
21881 { (char *)"Locale_AddCatalog", (PyCFunction) _wrap_Locale_AddCatalog, METH_VARARGS | METH_KEYWORDS, NULL},
21882 { (char *)"Locale_IsLoaded", (PyCFunction) _wrap_Locale_IsLoaded, METH_VARARGS | METH_KEYWORDS, NULL},
21883 { (char *)"Locale_GetLanguageInfo", (PyCFunction) _wrap_Locale_GetLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21884 { (char *)"Locale_GetLanguageName", (PyCFunction) _wrap_Locale_GetLanguageName, METH_VARARGS | METH_KEYWORDS, NULL},
21885 { (char *)"Locale_FindLanguageInfo", (PyCFunction) _wrap_Locale_FindLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21886 { (char *)"Locale_AddLanguage", (PyCFunction) _wrap_Locale_AddLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
21887 { (char *)"Locale_GetString", (PyCFunction) _wrap_Locale_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
21888 { (char *)"Locale_GetName", (PyCFunction) _wrap_Locale_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
21889 { (char *)"Locale_swigregister", Locale_swigregister, METH_VARARGS, NULL},
21890 { (char *)"GetLocale", (PyCFunction) _wrap_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
21891 { (char *)"GetTranslation", _wrap_GetTranslation, METH_VARARGS, NULL},
21892 { (char *)"new_EncodingConverter", (PyCFunction) _wrap_new_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
21893 { (char *)"delete_EncodingConverter", (PyCFunction) _wrap_delete_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
21894 { (char *)"EncodingConverter_Init", (PyCFunction) _wrap_EncodingConverter_Init, METH_VARARGS | METH_KEYWORDS, NULL},
21895 { (char *)"EncodingConverter_Convert", (PyCFunction) _wrap_EncodingConverter_Convert, METH_VARARGS | METH_KEYWORDS, NULL},
21896 { (char *)"EncodingConverter_GetPlatformEquivalents", (PyCFunction) _wrap_EncodingConverter_GetPlatformEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
21897 { (char *)"EncodingConverter_GetAllEquivalents", (PyCFunction) _wrap_EncodingConverter_GetAllEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
21898 { (char *)"EncodingConverter_CanConvert", (PyCFunction) _wrap_EncodingConverter_CanConvert, METH_VARARGS | METH_KEYWORDS, NULL},
21899 { (char *)"EncodingConverter_swigregister", EncodingConverter_swigregister, METH_VARARGS, NULL},
21900 { (char *)"delete_DC", (PyCFunction) _wrap_delete_DC, METH_VARARGS | METH_KEYWORDS, NULL},
21901 { (char *)"DC_BeginDrawing", (PyCFunction) _wrap_DC_BeginDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
21902 { (char *)"DC_EndDrawing", (PyCFunction) _wrap_DC_EndDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
21903 { (char *)"DC_FloodFill", (PyCFunction) _wrap_DC_FloodFill, METH_VARARGS | METH_KEYWORDS, NULL},
21904 { (char *)"DC_FloodFillPoint", (PyCFunction) _wrap_DC_FloodFillPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21905 { (char *)"DC_GetPixel", (PyCFunction) _wrap_DC_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
21906 { (char *)"DC_GetPixelPoint", (PyCFunction) _wrap_DC_GetPixelPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21907 { (char *)"DC_DrawLine", (PyCFunction) _wrap_DC_DrawLine, METH_VARARGS | METH_KEYWORDS, NULL},
21908 { (char *)"DC_DrawLinePoint", (PyCFunction) _wrap_DC_DrawLinePoint, METH_VARARGS | METH_KEYWORDS, NULL},
21909 { (char *)"DC_CrossHair", (PyCFunction) _wrap_DC_CrossHair, METH_VARARGS | METH_KEYWORDS, NULL},
21910 { (char *)"DC_CrossHairPoint", (PyCFunction) _wrap_DC_CrossHairPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21911 { (char *)"DC_DrawArc", (PyCFunction) _wrap_DC_DrawArc, METH_VARARGS | METH_KEYWORDS, NULL},
21912 { (char *)"DC_DrawArcPoint", (PyCFunction) _wrap_DC_DrawArcPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21913 { (char *)"DC_DrawCheckMark", (PyCFunction) _wrap_DC_DrawCheckMark, METH_VARARGS | METH_KEYWORDS, NULL},
21914 { (char *)"DC_DrawCheckMarkRect", (PyCFunction) _wrap_DC_DrawCheckMarkRect, METH_VARARGS | METH_KEYWORDS, NULL},
21915 { (char *)"DC_DrawEllipticArc", (PyCFunction) _wrap_DC_DrawEllipticArc, METH_VARARGS | METH_KEYWORDS, NULL},
21916 { (char *)"DC_DrawEllipticArcPointSize", (PyCFunction) _wrap_DC_DrawEllipticArcPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21917 { (char *)"DC_DrawPoint", (PyCFunction) _wrap_DC_DrawPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21918 { (char *)"DC_DrawPointPoint", (PyCFunction) _wrap_DC_DrawPointPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21919 { (char *)"DC_DrawRectangle", (PyCFunction) _wrap_DC_DrawRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
21920 { (char *)"DC_DrawRectangleRect", (PyCFunction) _wrap_DC_DrawRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
21921 { (char *)"DC_DrawRectanglePointSize", (PyCFunction) _wrap_DC_DrawRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21922 { (char *)"DC_DrawRoundedRectangle", (PyCFunction) _wrap_DC_DrawRoundedRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
21923 { (char *)"DC_DrawRoundedRectangleRect", (PyCFunction) _wrap_DC_DrawRoundedRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
21924 { (char *)"DC_DrawRoundedRectanglePointSize", (PyCFunction) _wrap_DC_DrawRoundedRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21925 { (char *)"DC_DrawCircle", (PyCFunction) _wrap_DC_DrawCircle, METH_VARARGS | METH_KEYWORDS, NULL},
21926 { (char *)"DC_DrawCirclePoint", (PyCFunction) _wrap_DC_DrawCirclePoint, METH_VARARGS | METH_KEYWORDS, NULL},
21927 { (char *)"DC_DrawEllipse", (PyCFunction) _wrap_DC_DrawEllipse, METH_VARARGS | METH_KEYWORDS, NULL},
21928 { (char *)"DC_DrawEllipseRect", (PyCFunction) _wrap_DC_DrawEllipseRect, METH_VARARGS | METH_KEYWORDS, NULL},
21929 { (char *)"DC_DrawEllipsePointSize", (PyCFunction) _wrap_DC_DrawEllipsePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21930 { (char *)"DC_DrawIcon", (PyCFunction) _wrap_DC_DrawIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21931 { (char *)"DC_DrawIconPoint", (PyCFunction) _wrap_DC_DrawIconPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21932 { (char *)"DC_DrawBitmap", (PyCFunction) _wrap_DC_DrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21933 { (char *)"DC_DrawBitmapPoint", (PyCFunction) _wrap_DC_DrawBitmapPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21934 { (char *)"DC_DrawText", (PyCFunction) _wrap_DC_DrawText, METH_VARARGS | METH_KEYWORDS, NULL},
21935 { (char *)"DC_DrawTextPoint", (PyCFunction) _wrap_DC_DrawTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21936 { (char *)"DC_DrawRotatedText", (PyCFunction) _wrap_DC_DrawRotatedText, METH_VARARGS | METH_KEYWORDS, NULL},
21937 { (char *)"DC_DrawRotatedTextPoint", (PyCFunction) _wrap_DC_DrawRotatedTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21938 { (char *)"DC_Blit", (PyCFunction) _wrap_DC_Blit, METH_VARARGS | METH_KEYWORDS, NULL},
21939 { (char *)"DC_BlitPointSize", (PyCFunction) _wrap_DC_BlitPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21940 { (char *)"DC_SetClippingRegion", (PyCFunction) _wrap_DC_SetClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21941 { (char *)"DC_SetClippingRegionPointSize", (PyCFunction) _wrap_DC_SetClippingRegionPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21942 { (char *)"DC_SetClippingRegionAsRegion", (PyCFunction) _wrap_DC_SetClippingRegionAsRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21943 { (char *)"DC_SetClippingRect", (PyCFunction) _wrap_DC_SetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
21944 { (char *)"DC_DrawLines", (PyCFunction) _wrap_DC_DrawLines, METH_VARARGS | METH_KEYWORDS, NULL},
21945 { (char *)"DC_DrawPolygon", (PyCFunction) _wrap_DC_DrawPolygon, METH_VARARGS | METH_KEYWORDS, NULL},
21946 { (char *)"DC_DrawLabel", (PyCFunction) _wrap_DC_DrawLabel, METH_VARARGS | METH_KEYWORDS, NULL},
21947 { (char *)"DC_DrawImageLabel", (PyCFunction) _wrap_DC_DrawImageLabel, METH_VARARGS | METH_KEYWORDS, NULL},
21948 { (char *)"DC_DrawSpline", (PyCFunction) _wrap_DC_DrawSpline, METH_VARARGS | METH_KEYWORDS, NULL},
21949 { (char *)"DC_Clear", (PyCFunction) _wrap_DC_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
21950 { (char *)"DC_StartDoc", (PyCFunction) _wrap_DC_StartDoc, METH_VARARGS | METH_KEYWORDS, NULL},
21951 { (char *)"DC_EndDoc", (PyCFunction) _wrap_DC_EndDoc, METH_VARARGS | METH_KEYWORDS, NULL},
21952 { (char *)"DC_StartPage", (PyCFunction) _wrap_DC_StartPage, METH_VARARGS | METH_KEYWORDS, NULL},
21953 { (char *)"DC_EndPage", (PyCFunction) _wrap_DC_EndPage, METH_VARARGS | METH_KEYWORDS, NULL},
21954 { (char *)"DC_SetFont", (PyCFunction) _wrap_DC_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
21955 { (char *)"DC_SetPen", (PyCFunction) _wrap_DC_SetPen, METH_VARARGS | METH_KEYWORDS, NULL},
21956 { (char *)"DC_SetBrush", (PyCFunction) _wrap_DC_SetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21957 { (char *)"DC_SetBackground", (PyCFunction) _wrap_DC_SetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21958 { (char *)"DC_SetBackgroundMode", (PyCFunction) _wrap_DC_SetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
21959 { (char *)"DC_SetPalette", (PyCFunction) _wrap_DC_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
21960 { (char *)"DC_DestroyClippingRegion", (PyCFunction) _wrap_DC_DestroyClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21961 { (char *)"DC_GetClippingBox", (PyCFunction) _wrap_DC_GetClippingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21962 { (char *)"DC_GetClippingRect", (PyCFunction) _wrap_DC_GetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
21963 { (char *)"DC_GetCharHeight", (PyCFunction) _wrap_DC_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21964 { (char *)"DC_GetCharWidth", (PyCFunction) _wrap_DC_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21965 { (char *)"DC_GetTextExtent", (PyCFunction) _wrap_DC_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21966 { (char *)"DC_GetFullTextExtent", (PyCFunction) _wrap_DC_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21967 { (char *)"DC_GetMultiLineTextExtent", (PyCFunction) _wrap_DC_GetMultiLineTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21968 { (char *)"DC_GetPartialTextExtents", (PyCFunction) _wrap_DC_GetPartialTextExtents, METH_VARARGS | METH_KEYWORDS, NULL},
21969 { (char *)"DC_GetSize", (PyCFunction) _wrap_DC_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21970 { (char *)"DC_GetSizeTuple", (PyCFunction) _wrap_DC_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21971 { (char *)"DC_GetSizeMM", (PyCFunction) _wrap_DC_GetSizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
21972 { (char *)"DC_GetSizeMMTuple", (PyCFunction) _wrap_DC_GetSizeMMTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21973 { (char *)"DC_DeviceToLogicalX", (PyCFunction) _wrap_DC_DeviceToLogicalX, METH_VARARGS | METH_KEYWORDS, NULL},
21974 { (char *)"DC_DeviceToLogicalY", (PyCFunction) _wrap_DC_DeviceToLogicalY, METH_VARARGS | METH_KEYWORDS, NULL},
21975 { (char *)"DC_DeviceToLogicalXRel", (PyCFunction) _wrap_DC_DeviceToLogicalXRel, METH_VARARGS | METH_KEYWORDS, NULL},
21976 { (char *)"DC_DeviceToLogicalYRel", (PyCFunction) _wrap_DC_DeviceToLogicalYRel, METH_VARARGS | METH_KEYWORDS, NULL},
21977 { (char *)"DC_LogicalToDeviceX", (PyCFunction) _wrap_DC_LogicalToDeviceX, METH_VARARGS | METH_KEYWORDS, NULL},
21978 { (char *)"DC_LogicalToDeviceY", (PyCFunction) _wrap_DC_LogicalToDeviceY, METH_VARARGS | METH_KEYWORDS, NULL},
21979 { (char *)"DC_LogicalToDeviceXRel", (PyCFunction) _wrap_DC_LogicalToDeviceXRel, METH_VARARGS | METH_KEYWORDS, NULL},
21980 { (char *)"DC_LogicalToDeviceYRel", (PyCFunction) _wrap_DC_LogicalToDeviceYRel, METH_VARARGS | METH_KEYWORDS, NULL},
21981 { (char *)"DC_CanDrawBitmap", (PyCFunction) _wrap_DC_CanDrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21982 { (char *)"DC_CanGetTextExtent", (PyCFunction) _wrap_DC_CanGetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21983 { (char *)"DC_GetDepth", (PyCFunction) _wrap_DC_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21984 { (char *)"DC_GetPPI", (PyCFunction) _wrap_DC_GetPPI, METH_VARARGS | METH_KEYWORDS, NULL},
21985 { (char *)"DC_Ok", (PyCFunction) _wrap_DC_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21986 { (char *)"DC_GetBackgroundMode", (PyCFunction) _wrap_DC_GetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
21987 { (char *)"DC_GetBackground", (PyCFunction) _wrap_DC_GetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21988 { (char *)"DC_GetBrush", (PyCFunction) _wrap_DC_GetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21989 { (char *)"DC_GetFont", (PyCFunction) _wrap_DC_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
21990 { (char *)"DC_GetPen", (PyCFunction) _wrap_DC_GetPen, METH_VARARGS | METH_KEYWORDS, NULL},
21991 { (char *)"DC_GetTextBackground", (PyCFunction) _wrap_DC_GetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21992 { (char *)"DC_GetTextForeground", (PyCFunction) _wrap_DC_GetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
21993 { (char *)"DC_SetTextForeground", (PyCFunction) _wrap_DC_SetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
21994 { (char *)"DC_SetTextBackground", (PyCFunction) _wrap_DC_SetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21995 { (char *)"DC_GetMapMode", (PyCFunction) _wrap_DC_GetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
21996 { (char *)"DC_SetMapMode", (PyCFunction) _wrap_DC_SetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
21997 { (char *)"DC_GetUserScale", (PyCFunction) _wrap_DC_GetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
21998 { (char *)"DC_SetUserScale", (PyCFunction) _wrap_DC_SetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
21999 { (char *)"DC_GetLogicalScale", (PyCFunction) _wrap_DC_GetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
22000 { (char *)"DC_SetLogicalScale", (PyCFunction) _wrap_DC_SetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
22001 { (char *)"DC_GetLogicalOrigin", (PyCFunction) _wrap_DC_GetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
22002 { (char *)"DC_GetLogicalOriginTuple", (PyCFunction) _wrap_DC_GetLogicalOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
22003 { (char *)"DC_SetLogicalOrigin", (PyCFunction) _wrap_DC_SetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
22004 { (char *)"DC_SetLogicalOriginPoint", (PyCFunction) _wrap_DC_SetLogicalOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22005 { (char *)"DC_GetDeviceOrigin", (PyCFunction) _wrap_DC_GetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
22006 { (char *)"DC_GetDeviceOriginTuple", (PyCFunction) _wrap_DC_GetDeviceOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
22007 { (char *)"DC_SetDeviceOrigin", (PyCFunction) _wrap_DC_SetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
22008 { (char *)"DC_SetDeviceOriginPoint", (PyCFunction) _wrap_DC_SetDeviceOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22009 { (char *)"DC_SetAxisOrientation", (PyCFunction) _wrap_DC_SetAxisOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
22010 { (char *)"DC_GetLogicalFunction", (PyCFunction) _wrap_DC_GetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
22011 { (char *)"DC_SetLogicalFunction", (PyCFunction) _wrap_DC_SetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
22012 { (char *)"DC_ComputeScaleAndOrigin", (PyCFunction) _wrap_DC_ComputeScaleAndOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
22013 { (char *)"DC_CalcBoundingBox", (PyCFunction) _wrap_DC_CalcBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
22014 { (char *)"DC_CalcBoundingBoxPoint", (PyCFunction) _wrap_DC_CalcBoundingBoxPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22015 { (char *)"DC_ResetBoundingBox", (PyCFunction) _wrap_DC_ResetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
22016 { (char *)"DC_MinX", (PyCFunction) _wrap_DC_MinX, METH_VARARGS | METH_KEYWORDS, NULL},
22017 { (char *)"DC_MaxX", (PyCFunction) _wrap_DC_MaxX, METH_VARARGS | METH_KEYWORDS, NULL},
22018 { (char *)"DC_MinY", (PyCFunction) _wrap_DC_MinY, METH_VARARGS | METH_KEYWORDS, NULL},
22019 { (char *)"DC_MaxY", (PyCFunction) _wrap_DC_MaxY, METH_VARARGS | METH_KEYWORDS, NULL},
22020 { (char *)"DC_GetBoundingBox", (PyCFunction) _wrap_DC_GetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
22021 { (char *)"DC__DrawPointList", (PyCFunction) _wrap_DC__DrawPointList, METH_VARARGS | METH_KEYWORDS, NULL},
22022 { (char *)"DC__DrawLineList", (PyCFunction) _wrap_DC__DrawLineList, METH_VARARGS | METH_KEYWORDS, NULL},
22023 { (char *)"DC__DrawRectangleList", (PyCFunction) _wrap_DC__DrawRectangleList, METH_VARARGS | METH_KEYWORDS, NULL},
22024 { (char *)"DC__DrawEllipseList", (PyCFunction) _wrap_DC__DrawEllipseList, METH_VARARGS | METH_KEYWORDS, NULL},
22025 { (char *)"DC__DrawPolygonList", (PyCFunction) _wrap_DC__DrawPolygonList, METH_VARARGS | METH_KEYWORDS, NULL},
22026 { (char *)"DC__DrawTextList", (PyCFunction) _wrap_DC__DrawTextList, METH_VARARGS | METH_KEYWORDS, NULL},
22027 { (char *)"DC_swigregister", DC_swigregister, METH_VARARGS, NULL},
22028 { (char *)"new_MemoryDC", (PyCFunction) _wrap_new_MemoryDC, METH_VARARGS | METH_KEYWORDS, NULL},
22029 { (char *)"new_MemoryDCFromDC", (PyCFunction) _wrap_new_MemoryDCFromDC, METH_VARARGS | METH_KEYWORDS, NULL},
22030 { (char *)"MemoryDC_SelectObject", (PyCFunction) _wrap_MemoryDC_SelectObject, METH_VARARGS | METH_KEYWORDS, NULL},
22031 { (char *)"MemoryDC_swigregister", MemoryDC_swigregister, METH_VARARGS, NULL},
22032 { (char *)"new_BufferedDC", _wrap_new_BufferedDC, METH_VARARGS, NULL},
22033 { (char *)"delete_BufferedDC", (PyCFunction) _wrap_delete_BufferedDC, METH_VARARGS | METH_KEYWORDS, NULL},
22034 { (char *)"BufferedDC_UnMask", (PyCFunction) _wrap_BufferedDC_UnMask, METH_VARARGS | METH_KEYWORDS, NULL},
22035 { (char *)"BufferedDC_swigregister", BufferedDC_swigregister, METH_VARARGS, NULL},
22036 { (char *)"new_BufferedPaintDC", (PyCFunction) _wrap_new_BufferedPaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
22037 { (char *)"BufferedPaintDC_swigregister", BufferedPaintDC_swigregister, METH_VARARGS, NULL},
22038 { (char *)"new_ScreenDC", (PyCFunction) _wrap_new_ScreenDC, METH_VARARGS | METH_KEYWORDS, NULL},
22039 { (char *)"ScreenDC_StartDrawingOnTopWin", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTopWin, METH_VARARGS | METH_KEYWORDS, NULL},
22040 { (char *)"ScreenDC_StartDrawingOnTop", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
22041 { (char *)"ScreenDC_EndDrawingOnTop", (PyCFunction) _wrap_ScreenDC_EndDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
22042 { (char *)"ScreenDC_swigregister", ScreenDC_swigregister, METH_VARARGS, NULL},
22043 { (char *)"new_ClientDC", (PyCFunction) _wrap_new_ClientDC, METH_VARARGS | METH_KEYWORDS, NULL},
22044 { (char *)"ClientDC_swigregister", ClientDC_swigregister, METH_VARARGS, NULL},
22045 { (char *)"new_PaintDC", (PyCFunction) _wrap_new_PaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
22046 { (char *)"PaintDC_swigregister", PaintDC_swigregister, METH_VARARGS, NULL},
22047 { (char *)"new_WindowDC", (PyCFunction) _wrap_new_WindowDC, METH_VARARGS | METH_KEYWORDS, NULL},
22048 { (char *)"WindowDC_swigregister", WindowDC_swigregister, METH_VARARGS, NULL},
22049 { (char *)"new_MirrorDC", (PyCFunction) _wrap_new_MirrorDC, METH_VARARGS | METH_KEYWORDS, NULL},
22050 { (char *)"MirrorDC_swigregister", MirrorDC_swigregister, METH_VARARGS, NULL},
22051 { (char *)"new_PostScriptDC", (PyCFunction) _wrap_new_PostScriptDC, METH_VARARGS | METH_KEYWORDS, NULL},
22052 { (char *)"PostScriptDC_GetPrintData", (PyCFunction) _wrap_PostScriptDC_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
22053 { (char *)"PostScriptDC_SetPrintData", (PyCFunction) _wrap_PostScriptDC_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
22054 { (char *)"PostScriptDC_SetResolution", (PyCFunction) _wrap_PostScriptDC_SetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
22055 { (char *)"PostScriptDC_GetResolution", (PyCFunction) _wrap_PostScriptDC_GetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
22056 { (char *)"PostScriptDC_swigregister", PostScriptDC_swigregister, METH_VARARGS, NULL},
22057 { (char *)"new_MetaFile", (PyCFunction) _wrap_new_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
22058 { (char *)"delete_MetaFile", (PyCFunction) _wrap_delete_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
22059 { (char *)"MetaFile_Ok", (PyCFunction) _wrap_MetaFile_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
22060 { (char *)"MetaFile_SetClipboard", (PyCFunction) _wrap_MetaFile_SetClipboard, METH_VARARGS | METH_KEYWORDS, NULL},
22061 { (char *)"MetaFile_GetSize", (PyCFunction) _wrap_MetaFile_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
22062 { (char *)"MetaFile_GetWidth", (PyCFunction) _wrap_MetaFile_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22063 { (char *)"MetaFile_GetHeight", (PyCFunction) _wrap_MetaFile_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
22064 { (char *)"MetaFile_swigregister", MetaFile_swigregister, METH_VARARGS, NULL},
22065 { (char *)"new_MetaFileDC", (PyCFunction) _wrap_new_MetaFileDC, METH_VARARGS | METH_KEYWORDS, NULL},
22066 { (char *)"MetaFileDC_Close", (PyCFunction) _wrap_MetaFileDC_Close, METH_VARARGS | METH_KEYWORDS, NULL},
22067 { (char *)"MetaFileDC_swigregister", MetaFileDC_swigregister, METH_VARARGS, NULL},
22068 { (char *)"new_PrinterDC", (PyCFunction) _wrap_new_PrinterDC, METH_VARARGS | METH_KEYWORDS, NULL},
22069 { (char *)"PrinterDC_swigregister", PrinterDC_swigregister, METH_VARARGS, NULL},
22070 { (char *)"new_ImageList", (PyCFunction) _wrap_new_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
22071 { (char *)"delete_ImageList", (PyCFunction) _wrap_delete_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
22072 { (char *)"ImageList_Add", (PyCFunction) _wrap_ImageList_Add, METH_VARARGS | METH_KEYWORDS, NULL},
22073 { (char *)"ImageList_AddWithColourMask", (PyCFunction) _wrap_ImageList_AddWithColourMask, METH_VARARGS | METH_KEYWORDS, NULL},
22074 { (char *)"ImageList_AddIcon", (PyCFunction) _wrap_ImageList_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
22075 { (char *)"ImageList_GetBitmap", (PyCFunction) _wrap_ImageList_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22076 { (char *)"ImageList_GetIcon", (PyCFunction) _wrap_ImageList_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
22077 { (char *)"ImageList_Replace", (PyCFunction) _wrap_ImageList_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
22078 { (char *)"ImageList_Draw", (PyCFunction) _wrap_ImageList_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
22079 { (char *)"ImageList_GetImageCount", (PyCFunction) _wrap_ImageList_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
22080 { (char *)"ImageList_Remove", (PyCFunction) _wrap_ImageList_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
22081 { (char *)"ImageList_RemoveAll", (PyCFunction) _wrap_ImageList_RemoveAll, METH_VARARGS | METH_KEYWORDS, NULL},
22082 { (char *)"ImageList_GetSize", (PyCFunction) _wrap_ImageList_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
22083 { (char *)"ImageList_swigregister", ImageList_swigregister, METH_VARARGS, NULL},
22084 { (char *)"PenList_AddPen", (PyCFunction) _wrap_PenList_AddPen, METH_VARARGS | METH_KEYWORDS, NULL},
22085 { (char *)"PenList_FindOrCreatePen", (PyCFunction) _wrap_PenList_FindOrCreatePen, METH_VARARGS | METH_KEYWORDS, NULL},
22086 { (char *)"PenList_RemovePen", (PyCFunction) _wrap_PenList_RemovePen, METH_VARARGS | METH_KEYWORDS, NULL},
22087 { (char *)"PenList_GetCount", (PyCFunction) _wrap_PenList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
22088 { (char *)"PenList_swigregister", PenList_swigregister, METH_VARARGS, NULL},
22089 { (char *)"BrushList_AddBrush", (PyCFunction) _wrap_BrushList_AddBrush, METH_VARARGS | METH_KEYWORDS, NULL},
22090 { (char *)"BrushList_FindOrCreateBrush", (PyCFunction) _wrap_BrushList_FindOrCreateBrush, METH_VARARGS | METH_KEYWORDS, NULL},
22091 { (char *)"BrushList_RemoveBrush", (PyCFunction) _wrap_BrushList_RemoveBrush, METH_VARARGS | METH_KEYWORDS, NULL},
22092 { (char *)"BrushList_GetCount", (PyCFunction) _wrap_BrushList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
22093 { (char *)"BrushList_swigregister", BrushList_swigregister, METH_VARARGS, NULL},
22094 { (char *)"new_ColourDatabase", (PyCFunction) _wrap_new_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
22095 { (char *)"delete_ColourDatabase", (PyCFunction) _wrap_delete_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
22096 { (char *)"ColourDatabase_Find", (PyCFunction) _wrap_ColourDatabase_Find, METH_VARARGS | METH_KEYWORDS, NULL},
22097 { (char *)"ColourDatabase_FindName", (PyCFunction) _wrap_ColourDatabase_FindName, METH_VARARGS | METH_KEYWORDS, NULL},
22098 { (char *)"ColourDatabase_AddColour", (PyCFunction) _wrap_ColourDatabase_AddColour, METH_VARARGS | METH_KEYWORDS, NULL},
22099 { (char *)"ColourDatabase_Append", (PyCFunction) _wrap_ColourDatabase_Append, METH_VARARGS | METH_KEYWORDS, NULL},
22100 { (char *)"ColourDatabase_swigregister", ColourDatabase_swigregister, METH_VARARGS, NULL},
22101 { (char *)"FontList_AddFont", (PyCFunction) _wrap_FontList_AddFont, METH_VARARGS | METH_KEYWORDS, NULL},
22102 { (char *)"FontList_FindOrCreateFont", (PyCFunction) _wrap_FontList_FindOrCreateFont, METH_VARARGS | METH_KEYWORDS, NULL},
22103 { (char *)"FontList_RemoveFont", (PyCFunction) _wrap_FontList_RemoveFont, METH_VARARGS | METH_KEYWORDS, NULL},
22104 { (char *)"FontList_GetCount", (PyCFunction) _wrap_FontList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
22105 { (char *)"FontList_swigregister", FontList_swigregister, METH_VARARGS, NULL},
22106 { (char *)"new_Effects", (PyCFunction) _wrap_new_Effects, METH_VARARGS | METH_KEYWORDS, NULL},
22107 { (char *)"Effects_GetHighlightColour", (PyCFunction) _wrap_Effects_GetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
22108 { (char *)"Effects_GetLightShadow", (PyCFunction) _wrap_Effects_GetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22109 { (char *)"Effects_GetFaceColour", (PyCFunction) _wrap_Effects_GetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
22110 { (char *)"Effects_GetMediumShadow", (PyCFunction) _wrap_Effects_GetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22111 { (char *)"Effects_GetDarkShadow", (PyCFunction) _wrap_Effects_GetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22112 { (char *)"Effects_SetHighlightColour", (PyCFunction) _wrap_Effects_SetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
22113 { (char *)"Effects_SetLightShadow", (PyCFunction) _wrap_Effects_SetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22114 { (char *)"Effects_SetFaceColour", (PyCFunction) _wrap_Effects_SetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
22115 { (char *)"Effects_SetMediumShadow", (PyCFunction) _wrap_Effects_SetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22116 { (char *)"Effects_SetDarkShadow", (PyCFunction) _wrap_Effects_SetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22117 { (char *)"Effects_Set", (PyCFunction) _wrap_Effects_Set, METH_VARARGS | METH_KEYWORDS, NULL},
22118 { (char *)"Effects_DrawSunkenEdge", (PyCFunction) _wrap_Effects_DrawSunkenEdge, METH_VARARGS | METH_KEYWORDS, NULL},
22119 { (char *)"Effects_TileBitmap", (PyCFunction) _wrap_Effects_TileBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22120 { (char *)"Effects_swigregister", Effects_swigregister, METH_VARARGS, NULL},
22121 { (char *)"new_SplitterRenderParams", (PyCFunction) _wrap_new_SplitterRenderParams, METH_VARARGS | METH_KEYWORDS, NULL},
22122 { (char *)"delete_SplitterRenderParams", (PyCFunction) _wrap_delete_SplitterRenderParams, METH_VARARGS | METH_KEYWORDS, NULL},
22123 { (char *)"SplitterRenderParams_widthSash_get", (PyCFunction) _wrap_SplitterRenderParams_widthSash_get, METH_VARARGS | METH_KEYWORDS, NULL},
22124 { (char *)"SplitterRenderParams_border_get", (PyCFunction) _wrap_SplitterRenderParams_border_get, METH_VARARGS | METH_KEYWORDS, NULL},
22125 { (char *)"SplitterRenderParams_isHotSensitive_get", (PyCFunction) _wrap_SplitterRenderParams_isHotSensitive_get, METH_VARARGS | METH_KEYWORDS, NULL},
22126 { (char *)"SplitterRenderParams_swigregister", SplitterRenderParams_swigregister, METH_VARARGS, NULL},
22127 { (char *)"new_RendererVersion", (PyCFunction) _wrap_new_RendererVersion, METH_VARARGS | METH_KEYWORDS, NULL},
22128 { (char *)"delete_RendererVersion", (PyCFunction) _wrap_delete_RendererVersion, METH_VARARGS | METH_KEYWORDS, NULL},
22129 { (char *)"RendererVersion_IsCompatible", (PyCFunction) _wrap_RendererVersion_IsCompatible, METH_VARARGS | METH_KEYWORDS, NULL},
22130 { (char *)"RendererVersion_version_get", (PyCFunction) _wrap_RendererVersion_version_get, METH_VARARGS | METH_KEYWORDS, NULL},
22131 { (char *)"RendererVersion_age_get", (PyCFunction) _wrap_RendererVersion_age_get, METH_VARARGS | METH_KEYWORDS, NULL},
22132 { (char *)"RendererVersion_swigregister", RendererVersion_swigregister, METH_VARARGS, NULL},
22133 { (char *)"RendererNative_DrawHeaderButton", (PyCFunction) _wrap_RendererNative_DrawHeaderButton, METH_VARARGS | METH_KEYWORDS, NULL},
22134 { (char *)"RendererNative_DrawTreeItemButton", (PyCFunction) _wrap_RendererNative_DrawTreeItemButton, METH_VARARGS | METH_KEYWORDS, NULL},
22135 { (char *)"RendererNative_DrawSplitterBorder", (PyCFunction) _wrap_RendererNative_DrawSplitterBorder, METH_VARARGS | METH_KEYWORDS, NULL},
22136 { (char *)"RendererNative_DrawSplitterSash", (PyCFunction) _wrap_RendererNative_DrawSplitterSash, METH_VARARGS | METH_KEYWORDS, NULL},
22137 { (char *)"RendererNative_DrawComboBoxDropButton", (PyCFunction) _wrap_RendererNative_DrawComboBoxDropButton, METH_VARARGS | METH_KEYWORDS, NULL},
22138 { (char *)"RendererNative_DrawDropArrow", (PyCFunction) _wrap_RendererNative_DrawDropArrow, METH_VARARGS | METH_KEYWORDS, NULL},
22139 { (char *)"RendererNative_GetSplitterParams", (PyCFunction) _wrap_RendererNative_GetSplitterParams, METH_VARARGS | METH_KEYWORDS, NULL},
22140 { (char *)"RendererNative_Get", (PyCFunction) _wrap_RendererNative_Get, METH_VARARGS | METH_KEYWORDS, NULL},
22141 { (char *)"RendererNative_GetGeneric", (PyCFunction) _wrap_RendererNative_GetGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
22142 { (char *)"RendererNative_GetDefault", (PyCFunction) _wrap_RendererNative_GetDefault, METH_VARARGS | METH_KEYWORDS, NULL},
22143 { (char *)"RendererNative_Set", (PyCFunction) _wrap_RendererNative_Set, METH_VARARGS | METH_KEYWORDS, NULL},
22144 { (char *)"RendererNative_GetVersion", (PyCFunction) _wrap_RendererNative_GetVersion, METH_VARARGS | METH_KEYWORDS, NULL},
22145 { (char *)"RendererNative_swigregister", RendererNative_swigregister, METH_VARARGS, NULL},
22146 { NULL, NULL, 0, NULL }
22147 };
22148
22149
22150 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
22151
22152 static void *_p_wxBufferedDCTo_p_wxMemoryDC(void *x) {
22153 return (void *)((wxMemoryDC *) ((wxBufferedDC *) x));
22154 }
22155 static void *_p_wxBufferedPaintDCTo_p_wxMemoryDC(void *x) {
22156 return (void *)((wxMemoryDC *) (wxBufferedDC *) ((wxBufferedPaintDC *) x));
22157 }
22158 static void *_p_wxIconTo_p_wxGDIObject(void *x) {
22159 return (void *)((wxGDIObject *) ((wxIcon *) x));
22160 }
22161 static void *_p_wxPaletteTo_p_wxGDIObject(void *x) {
22162 return (void *)((wxGDIObject *) ((wxPalette *) x));
22163 }
22164 static void *_p_wxPenTo_p_wxGDIObject(void *x) {
22165 return (void *)((wxGDIObject *) ((wxPen *) x));
22166 }
22167 static void *_p_wxFontTo_p_wxGDIObject(void *x) {
22168 return (void *)((wxGDIObject *) ((wxFont *) x));
22169 }
22170 static void *_p_wxCursorTo_p_wxGDIObject(void *x) {
22171 return (void *)((wxGDIObject *) ((wxCursor *) x));
22172 }
22173 static void *_p_wxBitmapTo_p_wxGDIObject(void *x) {
22174 return (void *)((wxGDIObject *) ((wxBitmap *) x));
22175 }
22176 static void *_p_wxRegionTo_p_wxGDIObject(void *x) {
22177 return (void *)((wxGDIObject *) ((wxRegion *) x));
22178 }
22179 static void *_p_wxBrushTo_p_wxGDIObject(void *x) {
22180 return (void *)((wxGDIObject *) ((wxBrush *) x));
22181 }
22182 static void *_p_wxBufferedDCTo_p_wxDC(void *x) {
22183 return (void *)((wxDC *) (wxMemoryDC *) ((wxBufferedDC *) x));
22184 }
22185 static void *_p_wxScreenDCTo_p_wxDC(void *x) {
22186 return (void *)((wxDC *) ((wxScreenDC *) x));
22187 }
22188 static void *_p_wxMirrorDCTo_p_wxDC(void *x) {
22189 return (void *)((wxDC *) ((wxMirrorDC *) x));
22190 }
22191 static void *_p_wxMemoryDCTo_p_wxDC(void *x) {
22192 return (void *)((wxDC *) ((wxMemoryDC *) x));
22193 }
22194 static void *_p_wxWindowDCTo_p_wxDC(void *x) {
22195 return (void *)((wxDC *) ((wxWindowDC *) x));
22196 }
22197 static void *_p_wxMetaFileDCTo_p_wxDC(void *x) {
22198 return (void *)((wxDC *) ((wxMetaFileDC *) x));
22199 }
22200 static void *_p_wxBufferedPaintDCTo_p_wxDC(void *x) {
22201 return (void *)((wxDC *) (wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
22202 }
22203 static void *_p_wxClientDCTo_p_wxDC(void *x) {
22204 return (void *)((wxDC *) ((wxClientDC *) x));
22205 }
22206 static void *_p_wxPaintDCTo_p_wxDC(void *x) {
22207 return (void *)((wxDC *) ((wxPaintDC *) x));
22208 }
22209 static void *_p_wxPostScriptDCTo_p_wxDC(void *x) {
22210 return (void *)((wxDC *) ((wxPostScriptDC *) x));
22211 }
22212 static void *_p_wxPrinterDCTo_p_wxDC(void *x) {
22213 return (void *)((wxDC *) ((wxPrinterDC *) x));
22214 }
22215 static void *_p_wxBufferedPaintDCTo_p_wxBufferedDC(void *x) {
22216 return (void *)((wxBufferedDC *) ((wxBufferedPaintDC *) x));
22217 }
22218 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
22219 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
22220 }
22221 static void *_p_wxPenTo_p_wxObject(void *x) {
22222 return (void *)((wxObject *) (wxGDIObject *) ((wxPen *) x));
22223 }
22224 static void *_p_wxRegionIteratorTo_p_wxObject(void *x) {
22225 return (void *)((wxObject *) ((wxRegionIterator *) x));
22226 }
22227 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
22228 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
22229 }
22230 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
22231 return (void *)((wxObject *) ((wxSizerItem *) x));
22232 }
22233 static void *_p_wxColourDatabaseTo_p_wxObject(void *x) {
22234 return (void *)((wxObject *) ((wxColourDatabase *) x));
22235 }
22236 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
22237 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
22238 }
22239 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
22240 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
22241 }
22242 static void *_p_wxIconTo_p_wxObject(void *x) {
22243 return (void *)((wxObject *) (wxGDIObject *) ((wxIcon *) x));
22244 }
22245 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
22246 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
22247 }
22248 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
22249 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
22250 }
22251 static void *_p_wxSizerTo_p_wxObject(void *x) {
22252 return (void *)((wxObject *) ((wxSizer *) x));
22253 }
22254 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
22255 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
22256 }
22257 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
22258 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
22259 }
22260 static void *_p_wxPenListTo_p_wxObject(void *x) {
22261 return (void *)((wxObject *) ((wxPenList *) x));
22262 }
22263 static void *_p_wxEventTo_p_wxObject(void *x) {
22264 return (void *)((wxObject *) ((wxEvent *) x));
22265 }
22266 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
22267 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
22268 }
22269 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
22270 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
22271 }
22272 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
22273 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
22274 }
22275 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
22276 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
22277 }
22278 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
22279 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
22280 }
22281 static void *_p_wxDCTo_p_wxObject(void *x) {
22282 return (void *)((wxObject *) ((wxDC *) x));
22283 }
22284 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
22285 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
22286 }
22287 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
22288 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
22289 }
22290 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
22291 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
22292 }
22293 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
22294 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
22295 }
22296 static void *_p_wxControlTo_p_wxObject(void *x) {
22297 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
22298 }
22299 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
22300 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
22301 }
22302 static void *_p_wxClientDCTo_p_wxObject(void *x) {
22303 return (void *)((wxObject *) (wxDC *) ((wxClientDC *) x));
22304 }
22305 static void *_p_wxFSFileTo_p_wxObject(void *x) {
22306 return (void *)((wxObject *) ((wxFSFile *) x));
22307 }
22308 static void *_p_wxMemoryDCTo_p_wxObject(void *x) {
22309 return (void *)((wxObject *) (wxDC *) ((wxMemoryDC *) x));
22310 }
22311 static void *_p_wxRegionTo_p_wxObject(void *x) {
22312 return (void *)((wxObject *) (wxGDIObject *) ((wxRegion *) x));
22313 }
22314 static void *_p_wxPySizerTo_p_wxObject(void *x) {
22315 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
22316 }
22317 static void *_p_wxWindowDCTo_p_wxObject(void *x) {
22318 return (void *)((wxObject *) (wxDC *) ((wxWindowDC *) x));
22319 }
22320 static void *_p_wxGDIObjectTo_p_wxObject(void *x) {
22321 return (void *)((wxObject *) ((wxGDIObject *) x));
22322 }
22323 static void *_p_wxEffectsTo_p_wxObject(void *x) {
22324 return (void *)((wxObject *) ((wxEffects *) x));
22325 }
22326 static void *_p_wxPyEventTo_p_wxObject(void *x) {
22327 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
22328 }
22329 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
22330 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
22331 }
22332 static void *_p_wxPostScriptDCTo_p_wxObject(void *x) {
22333 return (void *)((wxObject *) (wxDC *) ((wxPostScriptDC *) x));
22334 }
22335 static void *_p_wxShowEventTo_p_wxObject(void *x) {
22336 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
22337 }
22338 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
22339 return (void *)((wxObject *) ((wxMenuItem *) x));
22340 }
22341 static void *_p_wxDateEventTo_p_wxObject(void *x) {
22342 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
22343 }
22344 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
22345 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
22346 }
22347 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
22348 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
22349 }
22350 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
22351 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
22352 }
22353 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
22354 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
22355 }
22356 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
22357 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
22358 }
22359 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
22360 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
22361 }
22362 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
22363 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
22364 }
22365 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
22366 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
22367 }
22368 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
22369 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
22370 }
22371 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
22372 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
22373 }
22374 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
22375 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
22376 }
22377 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
22378 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
22379 }
22380 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
22381 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
22382 }
22383 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
22384 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
22385 }
22386 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
22387 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
22388 }
22389 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
22390 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
22391 }
22392 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
22393 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
22394 }
22395 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
22396 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
22397 }
22398 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
22399 return (void *)((wxObject *) ((wxImageHandler *) x));
22400 }
22401 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
22402 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
22403 }
22404 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
22405 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
22406 }
22407 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
22408 return (void *)((wxObject *) ((wxEvtHandler *) x));
22409 }
22410 static void *_p_wxBufferedPaintDCTo_p_wxObject(void *x) {
22411 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
22412 }
22413 static void *_p_wxPaintDCTo_p_wxObject(void *x) {
22414 return (void *)((wxObject *) (wxDC *) ((wxPaintDC *) x));
22415 }
22416 static void *_p_wxPrinterDCTo_p_wxObject(void *x) {
22417 return (void *)((wxObject *) (wxDC *) ((wxPrinterDC *) x));
22418 }
22419 static void *_p_wxScreenDCTo_p_wxObject(void *x) {
22420 return (void *)((wxObject *) (wxDC *) ((wxScreenDC *) x));
22421 }
22422 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
22423 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
22424 }
22425 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
22426 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
22427 }
22428 static void *_p_wxImageTo_p_wxObject(void *x) {
22429 return (void *)((wxObject *) ((wxImage *) x));
22430 }
22431 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
22432 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
22433 }
22434 static void *_p_wxPaletteTo_p_wxObject(void *x) {
22435 return (void *)((wxObject *) (wxGDIObject *) ((wxPalette *) x));
22436 }
22437 static void *_p_wxBufferedDCTo_p_wxObject(void *x) {
22438 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *) ((wxBufferedDC *) x));
22439 }
22440 static void *_p_wxImageListTo_p_wxObject(void *x) {
22441 return (void *)((wxObject *) ((wxImageList *) x));
22442 }
22443 static void *_p_wxCursorTo_p_wxObject(void *x) {
22444 return (void *)((wxObject *) (wxGDIObject *) ((wxCursor *) x));
22445 }
22446 static void *_p_wxEncodingConverterTo_p_wxObject(void *x) {
22447 return (void *)((wxObject *) ((wxEncodingConverter *) x));
22448 }
22449 static void *_p_wxMirrorDCTo_p_wxObject(void *x) {
22450 return (void *)((wxObject *) (wxDC *) ((wxMirrorDC *) x));
22451 }
22452 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
22453 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
22454 }
22455 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
22456 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
22457 }
22458 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
22459 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
22460 }
22461 static void *_p_wxWindowTo_p_wxObject(void *x) {
22462 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
22463 }
22464 static void *_p_wxMenuTo_p_wxObject(void *x) {
22465 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
22466 }
22467 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
22468 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
22469 }
22470 static void *_p_wxMetaFileDCTo_p_wxObject(void *x) {
22471 return (void *)((wxObject *) (wxDC *) ((wxMetaFileDC *) x));
22472 }
22473 static void *_p_wxBrushListTo_p_wxObject(void *x) {
22474 return (void *)((wxObject *) ((wxBrushList *) x));
22475 }
22476 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
22477 return (void *)((wxObject *) ((wxFileSystem *) x));
22478 }
22479 static void *_p_wxBitmapTo_p_wxObject(void *x) {
22480 return (void *)((wxObject *) (wxGDIObject *) ((wxBitmap *) x));
22481 }
22482 static void *_p_wxMaskTo_p_wxObject(void *x) {
22483 return (void *)((wxObject *) ((wxMask *) x));
22484 }
22485 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
22486 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
22487 }
22488 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
22489 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
22490 }
22491 static void *_p_wxPyAppTo_p_wxObject(void *x) {
22492 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
22493 }
22494 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
22495 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
22496 }
22497 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
22498 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
22499 }
22500 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
22501 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
22502 }
22503 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
22504 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
22505 }
22506 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
22507 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
22508 }
22509 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
22510 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
22511 }
22512 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
22513 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
22514 }
22515 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
22516 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
22517 }
22518 static void *_p_wxFontTo_p_wxObject(void *x) {
22519 return (void *)((wxObject *) (wxGDIObject *) ((wxFont *) x));
22520 }
22521 static void *_p_wxBrushTo_p_wxObject(void *x) {
22522 return (void *)((wxObject *) (wxGDIObject *) ((wxBrush *) x));
22523 }
22524 static void *_p_wxMetaFileTo_p_wxObject(void *x) {
22525 return (void *)((wxObject *) ((wxMetaFile *) x));
22526 }
22527 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
22528 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
22529 }
22530 static void *_p_wxColourTo_p_wxObject(void *x) {
22531 return (void *)((wxObject *) ((wxColour *) x));
22532 }
22533 static void *_p_wxFontListTo_p_wxObject(void *x) {
22534 return (void *)((wxObject *) ((wxFontList *) x));
22535 }
22536 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
22537 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
22538 }
22539 static void *_p_wxValidatorTo_p_wxObject(void *x) {
22540 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
22541 }
22542 static void *_p_wxControlTo_p_wxWindow(void *x) {
22543 return (void *)((wxWindow *) ((wxControl *) x));
22544 }
22545 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
22546 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
22547 }
22548 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
22549 return (void *)((wxWindow *) ((wxMenuBar *) x));
22550 }
22551 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}};
22552 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}};
22553 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}};
22554 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}};
22555 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}};
22556 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}};
22557 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}};
22558 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}};
22559 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}};
22560 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}};
22561 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}};
22562 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}};
22563 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}};
22564 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}};
22565 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}};
22566 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}};
22567 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}};
22568 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}};
22569 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}};
22570 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}};
22571 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}};
22572 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}};
22573 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}};
22574 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}};
22575 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_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_wxPyImageHandler", _p_wxPyImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_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_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_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_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}};
22576 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}};
22577 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}};
22578 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}};
22579 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}};
22580 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}};
22581 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}};
22582 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}};
22583 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}};
22584 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}};
22585 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}};
22586 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}};
22587 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}};
22588 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}};
22589 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}};
22590 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}};
22591 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}};
22592 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}};
22593 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}};
22594 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}};
22595 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}};
22596 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}};
22597 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}};
22598 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}};
22599 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}};
22600 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}};
22601 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}};
22602 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}};
22603 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}};
22604 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}};
22605 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}};
22606 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}};
22607 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}};
22608 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}};
22609 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}};
22610 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}};
22611 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}};
22612 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}};
22613 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}};
22614 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}};
22615
22616 static swig_type_info *swig_types_initial[] = {
22617 _swigt__p_wxPostScriptDC,
22618 _swigt__p_wxBrush,
22619 _swigt__p_wxColour,
22620 _swigt__p_wxDC,
22621 _swigt__p_wxMirrorDC,
22622 _swigt__p_form_ops_t,
22623 _swigt__p_wxRendererVersion,
22624 _swigt__p_wxDuplexMode,
22625 _swigt__p_wxPyFontEnumerator,
22626 _swigt__p_char,
22627 _swigt__p_wxIconLocation,
22628 _swigt__p_wxImage,
22629 _swigt__p_wxMetaFileDC,
22630 _swigt__p_wxMask,
22631 _swigt__p_wxSize,
22632 _swigt__p_wxFont,
22633 _swigt__p_wxWindow,
22634 _swigt__p_double,
22635 _swigt__p_wxMemoryDC,
22636 _swigt__p_wxFontMapper,
22637 _swigt__p_wxEffects,
22638 _swigt__p_wxNativeEncodingInfo,
22639 _swigt__p_wxPalette,
22640 _swigt__p_wxBitmap,
22641 _swigt__p_wxObject,
22642 _swigt__p_wxRegionIterator,
22643 _swigt__p_wxRect,
22644 _swigt__p_wxPaperSize,
22645 _swigt__p_wxString,
22646 _swigt__unsigned_int,
22647 _swigt__p_unsigned_int,
22648 _swigt__p_wxPrinterDC,
22649 _swigt__p_wxIconBundle,
22650 _swigt__p_wxPoint,
22651 _swigt__p_wxDash,
22652 _swigt__p_wxScreenDC,
22653 _swigt__p_wxCursor,
22654 _swigt__p_wxClientDC,
22655 _swigt__p_wxBufferedDC,
22656 _swigt__p_wxImageList,
22657 _swigt__p_unsigned_char,
22658 _swigt__p_wxGDIObject,
22659 _swigt__p_wxIcon,
22660 _swigt__p_wxLocale,
22661 _swigt__ptrdiff_t,
22662 _swigt__std__ptrdiff_t,
22663 _swigt__p_wxRegion,
22664 _swigt__p_wxLanguageInfo,
22665 _swigt__p_wxWindowDC,
22666 _swigt__p_wxPrintData,
22667 _swigt__p_wxBrushList,
22668 _swigt__p_wxFontList,
22669 _swigt__p_wxPen,
22670 _swigt__p_wxBufferedPaintDC,
22671 _swigt__p_wxPaintDC,
22672 _swigt__p_wxPenList,
22673 _swigt__p_int,
22674 _swigt__p_wxMetaFile,
22675 _swigt__p_wxRendererNative,
22676 _swigt__p_unsigned_long,
22677 _swigt__p_wxNativeFontInfo,
22678 _swigt__p_wxEncodingConverter,
22679 _swigt__p_wxSplitterRenderParams,
22680 _swigt__p_wxColourDatabase,
22681 0
22682 };
22683
22684
22685 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
22686
22687 static swig_const_info swig_const_table[] = {
22688 {0, 0, 0, 0.0, 0, 0}};
22689
22690 #ifdef __cplusplus
22691 }
22692 #endif
22693
22694
22695 #ifdef __cplusplus
22696 extern "C" {
22697 #endif
22698
22699 /* Python-specific SWIG API */
22700 #define SWIG_newvarlink() SWIG_Python_newvarlink()
22701 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
22702 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
22703
22704 /* -----------------------------------------------------------------------------
22705 * global variable support code.
22706 * ----------------------------------------------------------------------------- */
22707
22708 typedef struct swig_globalvar {
22709 char *name; /* Name of global variable */
22710 PyObject *(*get_attr)(); /* Return the current value */
22711 int (*set_attr)(PyObject *); /* Set the value */
22712 struct swig_globalvar *next;
22713 } swig_globalvar;
22714
22715 typedef struct swig_varlinkobject {
22716 PyObject_HEAD
22717 swig_globalvar *vars;
22718 } swig_varlinkobject;
22719
22720 static PyObject *
22721 swig_varlink_repr(swig_varlinkobject *v) {
22722 v = v;
22723 return PyString_FromString("<Swig global variables>");
22724 }
22725
22726 static int
22727 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
22728 swig_globalvar *var;
22729 flags = flags;
22730 fprintf(fp,"Swig global variables { ");
22731 for (var = v->vars; var; var=var->next) {
22732 fprintf(fp,"%s", var->name);
22733 if (var->next) fprintf(fp,", ");
22734 }
22735 fprintf(fp," }\n");
22736 return 0;
22737 }
22738
22739 static PyObject *
22740 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
22741 swig_globalvar *var = v->vars;
22742 while (var) {
22743 if (strcmp(var->name,n) == 0) {
22744 return (*var->get_attr)();
22745 }
22746 var = var->next;
22747 }
22748 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22749 return NULL;
22750 }
22751
22752 static int
22753 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
22754 swig_globalvar *var = v->vars;
22755 while (var) {
22756 if (strcmp(var->name,n) == 0) {
22757 return (*var->set_attr)(p);
22758 }
22759 var = var->next;
22760 }
22761 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22762 return 1;
22763 }
22764
22765 static PyTypeObject varlinktype = {
22766 PyObject_HEAD_INIT(0)
22767 0, /* Number of items in variable part (ob_size) */
22768 (char *)"swigvarlink", /* Type name (tp_name) */
22769 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
22770 0, /* Itemsize (tp_itemsize) */
22771 0, /* Deallocator (tp_dealloc) */
22772 (printfunc) swig_varlink_print, /* Print (tp_print) */
22773 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
22774 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
22775 0, /* tp_compare */
22776 (reprfunc) swig_varlink_repr, /* tp_repr */
22777 0, /* tp_as_number */
22778 0, /* tp_as_sequence */
22779 0, /* tp_as_mapping */
22780 0, /* tp_hash */
22781 0, /* tp_call */
22782 0, /* tp_str */
22783 0, /* tp_getattro */
22784 0, /* tp_setattro */
22785 0, /* tp_as_buffer */
22786 0, /* tp_flags */
22787 0, /* tp_doc */
22788 #if PY_VERSION_HEX >= 0x02000000
22789 0, /* tp_traverse */
22790 0, /* tp_clear */
22791 #endif
22792 #if PY_VERSION_HEX >= 0x02010000
22793 0, /* tp_richcompare */
22794 0, /* tp_weaklistoffset */
22795 #endif
22796 #if PY_VERSION_HEX >= 0x02020000
22797 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
22798 #endif
22799 #if PY_VERSION_HEX >= 0x02030000
22800 0, /* tp_del */
22801 #endif
22802 #ifdef COUNT_ALLOCS
22803 0,0,0,0 /* tp_alloc -> tp_next */
22804 #endif
22805 };
22806
22807 /* Create a variable linking object for use later */
22808 static PyObject *
22809 SWIG_Python_newvarlink(void) {
22810 swig_varlinkobject *result = 0;
22811 result = PyMem_NEW(swig_varlinkobject,1);
22812 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
22813 result->ob_type = &varlinktype;
22814 result->vars = 0;
22815 result->ob_refcnt = 0;
22816 Py_XINCREF((PyObject *) result);
22817 return ((PyObject*) result);
22818 }
22819
22820 static void
22821 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
22822 swig_varlinkobject *v;
22823 swig_globalvar *gv;
22824 v= (swig_varlinkobject *) p;
22825 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
22826 gv->name = (char *) malloc(strlen(name)+1);
22827 strcpy(gv->name,name);
22828 gv->get_attr = get_attr;
22829 gv->set_attr = set_attr;
22830 gv->next = v->vars;
22831 v->vars = gv;
22832 }
22833
22834 /* -----------------------------------------------------------------------------
22835 * constants/methods manipulation
22836 * ----------------------------------------------------------------------------- */
22837
22838 /* Install Constants */
22839 static void
22840 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
22841 PyObject *obj = 0;
22842 size_t i;
22843 for (i = 0; constants[i].type; i++) {
22844 switch(constants[i].type) {
22845 case SWIG_PY_INT:
22846 obj = PyInt_FromLong(constants[i].lvalue);
22847 break;
22848 case SWIG_PY_FLOAT:
22849 obj = PyFloat_FromDouble(constants[i].dvalue);
22850 break;
22851 case SWIG_PY_STRING:
22852 if (constants[i].pvalue) {
22853 obj = PyString_FromString((char *) constants[i].pvalue);
22854 } else {
22855 Py_INCREF(Py_None);
22856 obj = Py_None;
22857 }
22858 break;
22859 case SWIG_PY_POINTER:
22860 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
22861 break;
22862 case SWIG_PY_BINARY:
22863 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
22864 break;
22865 default:
22866 obj = 0;
22867 break;
22868 }
22869 if (obj) {
22870 PyDict_SetItemString(d,constants[i].name,obj);
22871 Py_DECREF(obj);
22872 }
22873 }
22874 }
22875
22876 /* -----------------------------------------------------------------------------*/
22877 /* Fix SwigMethods to carry the callback ptrs when needed */
22878 /* -----------------------------------------------------------------------------*/
22879
22880 static void
22881 SWIG_Python_FixMethods(PyMethodDef *methods,
22882 swig_const_info *const_table,
22883 swig_type_info **types,
22884 swig_type_info **types_initial) {
22885 size_t i;
22886 for (i = 0; methods[i].ml_name; ++i) {
22887 char *c = methods[i].ml_doc;
22888 if (c && (c = strstr(c, "swig_ptr: "))) {
22889 int j;
22890 swig_const_info *ci = 0;
22891 char *name = c + 10;
22892 for (j = 0; const_table[j].type; j++) {
22893 if (strncmp(const_table[j].name, name,
22894 strlen(const_table[j].name)) == 0) {
22895 ci = &(const_table[j]);
22896 break;
22897 }
22898 }
22899 if (ci) {
22900 size_t shift = (ci->ptype) - types;
22901 swig_type_info *ty = types_initial[shift];
22902 size_t ldoc = (c - methods[i].ml_doc);
22903 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
22904 char *ndoc = (char*)malloc(ldoc + lptr + 10);
22905 char *buff = ndoc;
22906 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
22907 strncpy(buff, methods[i].ml_doc, ldoc);
22908 buff += ldoc;
22909 strncpy(buff, "swig_ptr: ", 10);
22910 buff += 10;
22911 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
22912 methods[i].ml_doc = ndoc;
22913 }
22914 }
22915 }
22916 }
22917
22918 /* -----------------------------------------------------------------------------*
22919 * Initialize type list
22920 * -----------------------------------------------------------------------------*/
22921
22922 #if PY_MAJOR_VERSION < 2
22923 /* PyModule_AddObject function was introduced in Python 2.0. The following function
22924 is copied out of Python/modsupport.c in python version 2.3.4 */
22925 static int
22926 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
22927 {
22928 PyObject *dict;
22929 if (!PyModule_Check(m)) {
22930 PyErr_SetString(PyExc_TypeError,
22931 "PyModule_AddObject() needs module as first arg");
22932 return -1;
22933 }
22934 if (!o) {
22935 PyErr_SetString(PyExc_TypeError,
22936 "PyModule_AddObject() needs non-NULL value");
22937 return -1;
22938 }
22939
22940 dict = PyModule_GetDict(m);
22941 if (dict == NULL) {
22942 /* Internal error -- modules must have a dict! */
22943 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
22944 PyModule_GetName(m));
22945 return -1;
22946 }
22947 if (PyDict_SetItemString(dict, name, o))
22948 return -1;
22949 Py_DECREF(o);
22950 return 0;
22951 }
22952 #endif
22953
22954 static swig_type_info **
22955 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
22956 static PyMethodDef swig_empty_runtime_method_table[] = {
22957 {
22958 NULL, NULL, 0, NULL
22959 }
22960 };/* Sentinel */
22961
22962 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
22963 swig_empty_runtime_method_table);
22964 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
22965 if (pointer && module) {
22966 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
22967 }
22968 return type_list_handle;
22969 }
22970
22971 static swig_type_info **
22972 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
22973 swig_type_info **type_pointer;
22974
22975 /* first check if module already created */
22976 type_pointer = SWIG_Python_GetTypeListHandle();
22977 if (type_pointer) {
22978 return type_pointer;
22979 } else {
22980 /* create a new module and variable */
22981 return SWIG_Python_SetTypeListHandle(type_list_handle);
22982 }
22983 }
22984
22985 #ifdef __cplusplus
22986 }
22987 #endif
22988
22989 /* -----------------------------------------------------------------------------*
22990 * Partial Init method
22991 * -----------------------------------------------------------------------------*/
22992
22993 #ifdef SWIG_LINK_RUNTIME
22994 #ifdef __cplusplus
22995 extern "C"
22996 #endif
22997 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
22998 #endif
22999
23000 #ifdef __cplusplus
23001 extern "C"
23002 #endif
23003 SWIGEXPORT(void) SWIG_init(void) {
23004 static PyObject *SWIG_globals = 0;
23005 static int typeinit = 0;
23006 PyObject *m, *d;
23007 int i;
23008 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
23009
23010 /* Fix SwigMethods to carry the callback ptrs when needed */
23011 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
23012
23013 m = Py_InitModule((char *) SWIG_name, SwigMethods);
23014 d = PyModule_GetDict(m);
23015
23016 if (!typeinit) {
23017 #ifdef SWIG_LINK_RUNTIME
23018 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
23019 #else
23020 # ifndef SWIG_STATIC_RUNTIME
23021 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
23022 # endif
23023 #endif
23024 for (i = 0; swig_types_initial[i]; i++) {
23025 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
23026 }
23027 typeinit = 1;
23028 }
23029 SWIG_InstallConstants(d,swig_const_table);
23030
23031 {
23032 PyDict_SetItemString(d,"OutRegion", SWIG_From_int((int)(wxOutRegion)));
23033 }
23034 {
23035 PyDict_SetItemString(d,"PartRegion", SWIG_From_int((int)(wxPartRegion)));
23036 }
23037 {
23038 PyDict_SetItemString(d,"InRegion", SWIG_From_int((int)(wxInRegion)));
23039 }
23040 {
23041 PyDict_SetItemString(d,"FONTFAMILY_DEFAULT", SWIG_From_int((int)(wxFONTFAMILY_DEFAULT)));
23042 }
23043 {
23044 PyDict_SetItemString(d,"FONTFAMILY_DECORATIVE", SWIG_From_int((int)(wxFONTFAMILY_DECORATIVE)));
23045 }
23046 {
23047 PyDict_SetItemString(d,"FONTFAMILY_ROMAN", SWIG_From_int((int)(wxFONTFAMILY_ROMAN)));
23048 }
23049 {
23050 PyDict_SetItemString(d,"FONTFAMILY_SCRIPT", SWIG_From_int((int)(wxFONTFAMILY_SCRIPT)));
23051 }
23052 {
23053 PyDict_SetItemString(d,"FONTFAMILY_SWISS", SWIG_From_int((int)(wxFONTFAMILY_SWISS)));
23054 }
23055 {
23056 PyDict_SetItemString(d,"FONTFAMILY_MODERN", SWIG_From_int((int)(wxFONTFAMILY_MODERN)));
23057 }
23058 {
23059 PyDict_SetItemString(d,"FONTFAMILY_TELETYPE", SWIG_From_int((int)(wxFONTFAMILY_TELETYPE)));
23060 }
23061 {
23062 PyDict_SetItemString(d,"FONTFAMILY_MAX", SWIG_From_int((int)(wxFONTFAMILY_MAX)));
23063 }
23064 {
23065 PyDict_SetItemString(d,"FONTFAMILY_UNKNOWN", SWIG_From_int((int)(wxFONTFAMILY_UNKNOWN)));
23066 }
23067 {
23068 PyDict_SetItemString(d,"FONTSTYLE_NORMAL", SWIG_From_int((int)(wxFONTSTYLE_NORMAL)));
23069 }
23070 {
23071 PyDict_SetItemString(d,"FONTSTYLE_ITALIC", SWIG_From_int((int)(wxFONTSTYLE_ITALIC)));
23072 }
23073 {
23074 PyDict_SetItemString(d,"FONTSTYLE_SLANT", SWIG_From_int((int)(wxFONTSTYLE_SLANT)));
23075 }
23076 {
23077 PyDict_SetItemString(d,"FONTSTYLE_MAX", SWIG_From_int((int)(wxFONTSTYLE_MAX)));
23078 }
23079 {
23080 PyDict_SetItemString(d,"FONTWEIGHT_NORMAL", SWIG_From_int((int)(wxFONTWEIGHT_NORMAL)));
23081 }
23082 {
23083 PyDict_SetItemString(d,"FONTWEIGHT_LIGHT", SWIG_From_int((int)(wxFONTWEIGHT_LIGHT)));
23084 }
23085 {
23086 PyDict_SetItemString(d,"FONTWEIGHT_BOLD", SWIG_From_int((int)(wxFONTWEIGHT_BOLD)));
23087 }
23088 {
23089 PyDict_SetItemString(d,"FONTWEIGHT_MAX", SWIG_From_int((int)(wxFONTWEIGHT_MAX)));
23090 }
23091 {
23092 PyDict_SetItemString(d,"FONTFLAG_DEFAULT", SWIG_From_int((int)(wxFONTFLAG_DEFAULT)));
23093 }
23094 {
23095 PyDict_SetItemString(d,"FONTFLAG_ITALIC", SWIG_From_int((int)(wxFONTFLAG_ITALIC)));
23096 }
23097 {
23098 PyDict_SetItemString(d,"FONTFLAG_SLANT", SWIG_From_int((int)(wxFONTFLAG_SLANT)));
23099 }
23100 {
23101 PyDict_SetItemString(d,"FONTFLAG_LIGHT", SWIG_From_int((int)(wxFONTFLAG_LIGHT)));
23102 }
23103 {
23104 PyDict_SetItemString(d,"FONTFLAG_BOLD", SWIG_From_int((int)(wxFONTFLAG_BOLD)));
23105 }
23106 {
23107 PyDict_SetItemString(d,"FONTFLAG_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_ANTIALIASED)));
23108 }
23109 {
23110 PyDict_SetItemString(d,"FONTFLAG_NOT_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_NOT_ANTIALIASED)));
23111 }
23112 {
23113 PyDict_SetItemString(d,"FONTFLAG_UNDERLINED", SWIG_From_int((int)(wxFONTFLAG_UNDERLINED)));
23114 }
23115 {
23116 PyDict_SetItemString(d,"FONTFLAG_STRIKETHROUGH", SWIG_From_int((int)(wxFONTFLAG_STRIKETHROUGH)));
23117 }
23118 {
23119 PyDict_SetItemString(d,"FONTFLAG_MASK", SWIG_From_int((int)(wxFONTFLAG_MASK)));
23120 }
23121 {
23122 PyDict_SetItemString(d,"FONTENCODING_SYSTEM", SWIG_From_int((int)(wxFONTENCODING_SYSTEM)));
23123 }
23124 {
23125 PyDict_SetItemString(d,"FONTENCODING_DEFAULT", SWIG_From_int((int)(wxFONTENCODING_DEFAULT)));
23126 }
23127 {
23128 PyDict_SetItemString(d,"FONTENCODING_ISO8859_1", SWIG_From_int((int)(wxFONTENCODING_ISO8859_1)));
23129 }
23130 {
23131 PyDict_SetItemString(d,"FONTENCODING_ISO8859_2", SWIG_From_int((int)(wxFONTENCODING_ISO8859_2)));
23132 }
23133 {
23134 PyDict_SetItemString(d,"FONTENCODING_ISO8859_3", SWIG_From_int((int)(wxFONTENCODING_ISO8859_3)));
23135 }
23136 {
23137 PyDict_SetItemString(d,"FONTENCODING_ISO8859_4", SWIG_From_int((int)(wxFONTENCODING_ISO8859_4)));
23138 }
23139 {
23140 PyDict_SetItemString(d,"FONTENCODING_ISO8859_5", SWIG_From_int((int)(wxFONTENCODING_ISO8859_5)));
23141 }
23142 {
23143 PyDict_SetItemString(d,"FONTENCODING_ISO8859_6", SWIG_From_int((int)(wxFONTENCODING_ISO8859_6)));
23144 }
23145 {
23146 PyDict_SetItemString(d,"FONTENCODING_ISO8859_7", SWIG_From_int((int)(wxFONTENCODING_ISO8859_7)));
23147 }
23148 {
23149 PyDict_SetItemString(d,"FONTENCODING_ISO8859_8", SWIG_From_int((int)(wxFONTENCODING_ISO8859_8)));
23150 }
23151 {
23152 PyDict_SetItemString(d,"FONTENCODING_ISO8859_9", SWIG_From_int((int)(wxFONTENCODING_ISO8859_9)));
23153 }
23154 {
23155 PyDict_SetItemString(d,"FONTENCODING_ISO8859_10", SWIG_From_int((int)(wxFONTENCODING_ISO8859_10)));
23156 }
23157 {
23158 PyDict_SetItemString(d,"FONTENCODING_ISO8859_11", SWIG_From_int((int)(wxFONTENCODING_ISO8859_11)));
23159 }
23160 {
23161 PyDict_SetItemString(d,"FONTENCODING_ISO8859_12", SWIG_From_int((int)(wxFONTENCODING_ISO8859_12)));
23162 }
23163 {
23164 PyDict_SetItemString(d,"FONTENCODING_ISO8859_13", SWIG_From_int((int)(wxFONTENCODING_ISO8859_13)));
23165 }
23166 {
23167 PyDict_SetItemString(d,"FONTENCODING_ISO8859_14", SWIG_From_int((int)(wxFONTENCODING_ISO8859_14)));
23168 }
23169 {
23170 PyDict_SetItemString(d,"FONTENCODING_ISO8859_15", SWIG_From_int((int)(wxFONTENCODING_ISO8859_15)));
23171 }
23172 {
23173 PyDict_SetItemString(d,"FONTENCODING_ISO8859_MAX", SWIG_From_int((int)(wxFONTENCODING_ISO8859_MAX)));
23174 }
23175 {
23176 PyDict_SetItemString(d,"FONTENCODING_KOI8", SWIG_From_int((int)(wxFONTENCODING_KOI8)));
23177 }
23178 {
23179 PyDict_SetItemString(d,"FONTENCODING_KOI8_U", SWIG_From_int((int)(wxFONTENCODING_KOI8_U)));
23180 }
23181 {
23182 PyDict_SetItemString(d,"FONTENCODING_ALTERNATIVE", SWIG_From_int((int)(wxFONTENCODING_ALTERNATIVE)));
23183 }
23184 {
23185 PyDict_SetItemString(d,"FONTENCODING_BULGARIAN", SWIG_From_int((int)(wxFONTENCODING_BULGARIAN)));
23186 }
23187 {
23188 PyDict_SetItemString(d,"FONTENCODING_CP437", SWIG_From_int((int)(wxFONTENCODING_CP437)));
23189 }
23190 {
23191 PyDict_SetItemString(d,"FONTENCODING_CP850", SWIG_From_int((int)(wxFONTENCODING_CP850)));
23192 }
23193 {
23194 PyDict_SetItemString(d,"FONTENCODING_CP852", SWIG_From_int((int)(wxFONTENCODING_CP852)));
23195 }
23196 {
23197 PyDict_SetItemString(d,"FONTENCODING_CP855", SWIG_From_int((int)(wxFONTENCODING_CP855)));
23198 }
23199 {
23200 PyDict_SetItemString(d,"FONTENCODING_CP866", SWIG_From_int((int)(wxFONTENCODING_CP866)));
23201 }
23202 {
23203 PyDict_SetItemString(d,"FONTENCODING_CP874", SWIG_From_int((int)(wxFONTENCODING_CP874)));
23204 }
23205 {
23206 PyDict_SetItemString(d,"FONTENCODING_CP932", SWIG_From_int((int)(wxFONTENCODING_CP932)));
23207 }
23208 {
23209 PyDict_SetItemString(d,"FONTENCODING_CP936", SWIG_From_int((int)(wxFONTENCODING_CP936)));
23210 }
23211 {
23212 PyDict_SetItemString(d,"FONTENCODING_CP949", SWIG_From_int((int)(wxFONTENCODING_CP949)));
23213 }
23214 {
23215 PyDict_SetItemString(d,"FONTENCODING_CP950", SWIG_From_int((int)(wxFONTENCODING_CP950)));
23216 }
23217 {
23218 PyDict_SetItemString(d,"FONTENCODING_CP1250", SWIG_From_int((int)(wxFONTENCODING_CP1250)));
23219 }
23220 {
23221 PyDict_SetItemString(d,"FONTENCODING_CP1251", SWIG_From_int((int)(wxFONTENCODING_CP1251)));
23222 }
23223 {
23224 PyDict_SetItemString(d,"FONTENCODING_CP1252", SWIG_From_int((int)(wxFONTENCODING_CP1252)));
23225 }
23226 {
23227 PyDict_SetItemString(d,"FONTENCODING_CP1253", SWIG_From_int((int)(wxFONTENCODING_CP1253)));
23228 }
23229 {
23230 PyDict_SetItemString(d,"FONTENCODING_CP1254", SWIG_From_int((int)(wxFONTENCODING_CP1254)));
23231 }
23232 {
23233 PyDict_SetItemString(d,"FONTENCODING_CP1255", SWIG_From_int((int)(wxFONTENCODING_CP1255)));
23234 }
23235 {
23236 PyDict_SetItemString(d,"FONTENCODING_CP1256", SWIG_From_int((int)(wxFONTENCODING_CP1256)));
23237 }
23238 {
23239 PyDict_SetItemString(d,"FONTENCODING_CP1257", SWIG_From_int((int)(wxFONTENCODING_CP1257)));
23240 }
23241 {
23242 PyDict_SetItemString(d,"FONTENCODING_CP12_MAX", SWIG_From_int((int)(wxFONTENCODING_CP12_MAX)));
23243 }
23244 {
23245 PyDict_SetItemString(d,"FONTENCODING_UTF7", SWIG_From_int((int)(wxFONTENCODING_UTF7)));
23246 }
23247 {
23248 PyDict_SetItemString(d,"FONTENCODING_UTF8", SWIG_From_int((int)(wxFONTENCODING_UTF8)));
23249 }
23250 {
23251 PyDict_SetItemString(d,"FONTENCODING_EUC_JP", SWIG_From_int((int)(wxFONTENCODING_EUC_JP)));
23252 }
23253 {
23254 PyDict_SetItemString(d,"FONTENCODING_UTF16BE", SWIG_From_int((int)(wxFONTENCODING_UTF16BE)));
23255 }
23256 {
23257 PyDict_SetItemString(d,"FONTENCODING_UTF16LE", SWIG_From_int((int)(wxFONTENCODING_UTF16LE)));
23258 }
23259 {
23260 PyDict_SetItemString(d,"FONTENCODING_UTF32BE", SWIG_From_int((int)(wxFONTENCODING_UTF32BE)));
23261 }
23262 {
23263 PyDict_SetItemString(d,"FONTENCODING_UTF32LE", SWIG_From_int((int)(wxFONTENCODING_UTF32LE)));
23264 }
23265 {
23266 PyDict_SetItemString(d,"FONTENCODING_MACROMAN", SWIG_From_int((int)(wxFONTENCODING_MACROMAN)));
23267 }
23268 {
23269 PyDict_SetItemString(d,"FONTENCODING_MACJAPANESE", SWIG_From_int((int)(wxFONTENCODING_MACJAPANESE)));
23270 }
23271 {
23272 PyDict_SetItemString(d,"FONTENCODING_MACCHINESETRAD", SWIG_From_int((int)(wxFONTENCODING_MACCHINESETRAD)));
23273 }
23274 {
23275 PyDict_SetItemString(d,"FONTENCODING_MACKOREAN", SWIG_From_int((int)(wxFONTENCODING_MACKOREAN)));
23276 }
23277 {
23278 PyDict_SetItemString(d,"FONTENCODING_MACARABIC", SWIG_From_int((int)(wxFONTENCODING_MACARABIC)));
23279 }
23280 {
23281 PyDict_SetItemString(d,"FONTENCODING_MACHEBREW", SWIG_From_int((int)(wxFONTENCODING_MACHEBREW)));
23282 }
23283 {
23284 PyDict_SetItemString(d,"FONTENCODING_MACGREEK", SWIG_From_int((int)(wxFONTENCODING_MACGREEK)));
23285 }
23286 {
23287 PyDict_SetItemString(d,"FONTENCODING_MACCYRILLIC", SWIG_From_int((int)(wxFONTENCODING_MACCYRILLIC)));
23288 }
23289 {
23290 PyDict_SetItemString(d,"FONTENCODING_MACDEVANAGARI", SWIG_From_int((int)(wxFONTENCODING_MACDEVANAGARI)));
23291 }
23292 {
23293 PyDict_SetItemString(d,"FONTENCODING_MACGURMUKHI", SWIG_From_int((int)(wxFONTENCODING_MACGURMUKHI)));
23294 }
23295 {
23296 PyDict_SetItemString(d,"FONTENCODING_MACGUJARATI", SWIG_From_int((int)(wxFONTENCODING_MACGUJARATI)));
23297 }
23298 {
23299 PyDict_SetItemString(d,"FONTENCODING_MACORIYA", SWIG_From_int((int)(wxFONTENCODING_MACORIYA)));
23300 }
23301 {
23302 PyDict_SetItemString(d,"FONTENCODING_MACBENGALI", SWIG_From_int((int)(wxFONTENCODING_MACBENGALI)));
23303 }
23304 {
23305 PyDict_SetItemString(d,"FONTENCODING_MACTAMIL", SWIG_From_int((int)(wxFONTENCODING_MACTAMIL)));
23306 }
23307 {
23308 PyDict_SetItemString(d,"FONTENCODING_MACTELUGU", SWIG_From_int((int)(wxFONTENCODING_MACTELUGU)));
23309 }
23310 {
23311 PyDict_SetItemString(d,"FONTENCODING_MACKANNADA", SWIG_From_int((int)(wxFONTENCODING_MACKANNADA)));
23312 }
23313 {
23314 PyDict_SetItemString(d,"FONTENCODING_MACMALAJALAM", SWIG_From_int((int)(wxFONTENCODING_MACMALAJALAM)));
23315 }
23316 {
23317 PyDict_SetItemString(d,"FONTENCODING_MACSINHALESE", SWIG_From_int((int)(wxFONTENCODING_MACSINHALESE)));
23318 }
23319 {
23320 PyDict_SetItemString(d,"FONTENCODING_MACBURMESE", SWIG_From_int((int)(wxFONTENCODING_MACBURMESE)));
23321 }
23322 {
23323 PyDict_SetItemString(d,"FONTENCODING_MACKHMER", SWIG_From_int((int)(wxFONTENCODING_MACKHMER)));
23324 }
23325 {
23326 PyDict_SetItemString(d,"FONTENCODING_MACTHAI", SWIG_From_int((int)(wxFONTENCODING_MACTHAI)));
23327 }
23328 {
23329 PyDict_SetItemString(d,"FONTENCODING_MACLAOTIAN", SWIG_From_int((int)(wxFONTENCODING_MACLAOTIAN)));
23330 }
23331 {
23332 PyDict_SetItemString(d,"FONTENCODING_MACGEORGIAN", SWIG_From_int((int)(wxFONTENCODING_MACGEORGIAN)));
23333 }
23334 {
23335 PyDict_SetItemString(d,"FONTENCODING_MACARMENIAN", SWIG_From_int((int)(wxFONTENCODING_MACARMENIAN)));
23336 }
23337 {
23338 PyDict_SetItemString(d,"FONTENCODING_MACCHINESESIMP", SWIG_From_int((int)(wxFONTENCODING_MACCHINESESIMP)));
23339 }
23340 {
23341 PyDict_SetItemString(d,"FONTENCODING_MACTIBETAN", SWIG_From_int((int)(wxFONTENCODING_MACTIBETAN)));
23342 }
23343 {
23344 PyDict_SetItemString(d,"FONTENCODING_MACMONGOLIAN", SWIG_From_int((int)(wxFONTENCODING_MACMONGOLIAN)));
23345 }
23346 {
23347 PyDict_SetItemString(d,"FONTENCODING_MACETHIOPIC", SWIG_From_int((int)(wxFONTENCODING_MACETHIOPIC)));
23348 }
23349 {
23350 PyDict_SetItemString(d,"FONTENCODING_MACCENTRALEUR", SWIG_From_int((int)(wxFONTENCODING_MACCENTRALEUR)));
23351 }
23352 {
23353 PyDict_SetItemString(d,"FONTENCODING_MACVIATNAMESE", SWIG_From_int((int)(wxFONTENCODING_MACVIATNAMESE)));
23354 }
23355 {
23356 PyDict_SetItemString(d,"FONTENCODING_MACARABICEXT", SWIG_From_int((int)(wxFONTENCODING_MACARABICEXT)));
23357 }
23358 {
23359 PyDict_SetItemString(d,"FONTENCODING_MACSYMBOL", SWIG_From_int((int)(wxFONTENCODING_MACSYMBOL)));
23360 }
23361 {
23362 PyDict_SetItemString(d,"FONTENCODING_MACDINGBATS", SWIG_From_int((int)(wxFONTENCODING_MACDINGBATS)));
23363 }
23364 {
23365 PyDict_SetItemString(d,"FONTENCODING_MACTURKISH", SWIG_From_int((int)(wxFONTENCODING_MACTURKISH)));
23366 }
23367 {
23368 PyDict_SetItemString(d,"FONTENCODING_MACCROATIAN", SWIG_From_int((int)(wxFONTENCODING_MACCROATIAN)));
23369 }
23370 {
23371 PyDict_SetItemString(d,"FONTENCODING_MACICELANDIC", SWIG_From_int((int)(wxFONTENCODING_MACICELANDIC)));
23372 }
23373 {
23374 PyDict_SetItemString(d,"FONTENCODING_MACROMANIAN", SWIG_From_int((int)(wxFONTENCODING_MACROMANIAN)));
23375 }
23376 {
23377 PyDict_SetItemString(d,"FONTENCODING_MACCELTIC", SWIG_From_int((int)(wxFONTENCODING_MACCELTIC)));
23378 }
23379 {
23380 PyDict_SetItemString(d,"FONTENCODING_MACGAELIC", SWIG_From_int((int)(wxFONTENCODING_MACGAELIC)));
23381 }
23382 {
23383 PyDict_SetItemString(d,"FONTENCODING_MACKEYBOARD", SWIG_From_int((int)(wxFONTENCODING_MACKEYBOARD)));
23384 }
23385 {
23386 PyDict_SetItemString(d,"FONTENCODING_MACMIN", SWIG_From_int((int)(wxFONTENCODING_MACMIN)));
23387 }
23388 {
23389 PyDict_SetItemString(d,"FONTENCODING_MACMAX", SWIG_From_int((int)(wxFONTENCODING_MACMAX)));
23390 }
23391 {
23392 PyDict_SetItemString(d,"FONTENCODING_MAX", SWIG_From_int((int)(wxFONTENCODING_MAX)));
23393 }
23394 {
23395 PyDict_SetItemString(d,"FONTENCODING_UTF16", SWIG_From_int((int)(wxFONTENCODING_UTF16)));
23396 }
23397 {
23398 PyDict_SetItemString(d,"FONTENCODING_UTF32", SWIG_From_int((int)(wxFONTENCODING_UTF32)));
23399 }
23400 {
23401 PyDict_SetItemString(d,"FONTENCODING_UNICODE", SWIG_From_int((int)(wxFONTENCODING_UNICODE)));
23402 }
23403 {
23404 PyDict_SetItemString(d,"FONTENCODING_GB2312", SWIG_From_int((int)(wxFONTENCODING_GB2312)));
23405 }
23406 {
23407 PyDict_SetItemString(d,"FONTENCODING_BIG5", SWIG_From_int((int)(wxFONTENCODING_BIG5)));
23408 }
23409 {
23410 PyDict_SetItemString(d,"FONTENCODING_SHIFT_JIS", SWIG_From_int((int)(wxFONTENCODING_SHIFT_JIS)));
23411 }
23412
23413 wxPyPtrTypeMap_Add("wxFontEnumerator", "wxPyFontEnumerator");
23414
23415 {
23416 PyDict_SetItemString(d,"LANGUAGE_DEFAULT", SWIG_From_int((int)(wxLANGUAGE_DEFAULT)));
23417 }
23418 {
23419 PyDict_SetItemString(d,"LANGUAGE_UNKNOWN", SWIG_From_int((int)(wxLANGUAGE_UNKNOWN)));
23420 }
23421 {
23422 PyDict_SetItemString(d,"LANGUAGE_ABKHAZIAN", SWIG_From_int((int)(wxLANGUAGE_ABKHAZIAN)));
23423 }
23424 {
23425 PyDict_SetItemString(d,"LANGUAGE_AFAR", SWIG_From_int((int)(wxLANGUAGE_AFAR)));
23426 }
23427 {
23428 PyDict_SetItemString(d,"LANGUAGE_AFRIKAANS", SWIG_From_int((int)(wxLANGUAGE_AFRIKAANS)));
23429 }
23430 {
23431 PyDict_SetItemString(d,"LANGUAGE_ALBANIAN", SWIG_From_int((int)(wxLANGUAGE_ALBANIAN)));
23432 }
23433 {
23434 PyDict_SetItemString(d,"LANGUAGE_AMHARIC", SWIG_From_int((int)(wxLANGUAGE_AMHARIC)));
23435 }
23436 {
23437 PyDict_SetItemString(d,"LANGUAGE_ARABIC", SWIG_From_int((int)(wxLANGUAGE_ARABIC)));
23438 }
23439 {
23440 PyDict_SetItemString(d,"LANGUAGE_ARABIC_ALGERIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_ALGERIA)));
23441 }
23442 {
23443 PyDict_SetItemString(d,"LANGUAGE_ARABIC_BAHRAIN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_BAHRAIN)));
23444 }
23445 {
23446 PyDict_SetItemString(d,"LANGUAGE_ARABIC_EGYPT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_EGYPT)));
23447 }
23448 {
23449 PyDict_SetItemString(d,"LANGUAGE_ARABIC_IRAQ", SWIG_From_int((int)(wxLANGUAGE_ARABIC_IRAQ)));
23450 }
23451 {
23452 PyDict_SetItemString(d,"LANGUAGE_ARABIC_JORDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_JORDAN)));
23453 }
23454 {
23455 PyDict_SetItemString(d,"LANGUAGE_ARABIC_KUWAIT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_KUWAIT)));
23456 }
23457 {
23458 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LEBANON", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LEBANON)));
23459 }
23460 {
23461 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LIBYA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LIBYA)));
23462 }
23463 {
23464 PyDict_SetItemString(d,"LANGUAGE_ARABIC_MOROCCO", SWIG_From_int((int)(wxLANGUAGE_ARABIC_MOROCCO)));
23465 }
23466 {
23467 PyDict_SetItemString(d,"LANGUAGE_ARABIC_OMAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_OMAN)));
23468 }
23469 {
23470 PyDict_SetItemString(d,"LANGUAGE_ARABIC_QATAR", SWIG_From_int((int)(wxLANGUAGE_ARABIC_QATAR)));
23471 }
23472 {
23473 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SAUDI_ARABIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SAUDI_ARABIA)));
23474 }
23475 {
23476 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SUDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SUDAN)));
23477 }
23478 {
23479 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SYRIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SYRIA)));
23480 }
23481 {
23482 PyDict_SetItemString(d,"LANGUAGE_ARABIC_TUNISIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_TUNISIA)));
23483 }
23484 {
23485 PyDict_SetItemString(d,"LANGUAGE_ARABIC_UAE", SWIG_From_int((int)(wxLANGUAGE_ARABIC_UAE)));
23486 }
23487 {
23488 PyDict_SetItemString(d,"LANGUAGE_ARABIC_YEMEN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_YEMEN)));
23489 }
23490 {
23491 PyDict_SetItemString(d,"LANGUAGE_ARMENIAN", SWIG_From_int((int)(wxLANGUAGE_ARMENIAN)));
23492 }
23493 {
23494 PyDict_SetItemString(d,"LANGUAGE_ASSAMESE", SWIG_From_int((int)(wxLANGUAGE_ASSAMESE)));
23495 }
23496 {
23497 PyDict_SetItemString(d,"LANGUAGE_AYMARA", SWIG_From_int((int)(wxLANGUAGE_AYMARA)));
23498 }
23499 {
23500 PyDict_SetItemString(d,"LANGUAGE_AZERI", SWIG_From_int((int)(wxLANGUAGE_AZERI)));
23501 }
23502 {
23503 PyDict_SetItemString(d,"LANGUAGE_AZERI_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_AZERI_CYRILLIC)));
23504 }
23505 {
23506 PyDict_SetItemString(d,"LANGUAGE_AZERI_LATIN", SWIG_From_int((int)(wxLANGUAGE_AZERI_LATIN)));
23507 }
23508 {
23509 PyDict_SetItemString(d,"LANGUAGE_BASHKIR", SWIG_From_int((int)(wxLANGUAGE_BASHKIR)));
23510 }
23511 {
23512 PyDict_SetItemString(d,"LANGUAGE_BASQUE", SWIG_From_int((int)(wxLANGUAGE_BASQUE)));
23513 }
23514 {
23515 PyDict_SetItemString(d,"LANGUAGE_BELARUSIAN", SWIG_From_int((int)(wxLANGUAGE_BELARUSIAN)));
23516 }
23517 {
23518 PyDict_SetItemString(d,"LANGUAGE_BENGALI", SWIG_From_int((int)(wxLANGUAGE_BENGALI)));
23519 }
23520 {
23521 PyDict_SetItemString(d,"LANGUAGE_BHUTANI", SWIG_From_int((int)(wxLANGUAGE_BHUTANI)));
23522 }
23523 {
23524 PyDict_SetItemString(d,"LANGUAGE_BIHARI", SWIG_From_int((int)(wxLANGUAGE_BIHARI)));
23525 }
23526 {
23527 PyDict_SetItemString(d,"LANGUAGE_BISLAMA", SWIG_From_int((int)(wxLANGUAGE_BISLAMA)));
23528 }
23529 {
23530 PyDict_SetItemString(d,"LANGUAGE_BRETON", SWIG_From_int((int)(wxLANGUAGE_BRETON)));
23531 }
23532 {
23533 PyDict_SetItemString(d,"LANGUAGE_BULGARIAN", SWIG_From_int((int)(wxLANGUAGE_BULGARIAN)));
23534 }
23535 {
23536 PyDict_SetItemString(d,"LANGUAGE_BURMESE", SWIG_From_int((int)(wxLANGUAGE_BURMESE)));
23537 }
23538 {
23539 PyDict_SetItemString(d,"LANGUAGE_CAMBODIAN", SWIG_From_int((int)(wxLANGUAGE_CAMBODIAN)));
23540 }
23541 {
23542 PyDict_SetItemString(d,"LANGUAGE_CATALAN", SWIG_From_int((int)(wxLANGUAGE_CATALAN)));
23543 }
23544 {
23545 PyDict_SetItemString(d,"LANGUAGE_CHINESE", SWIG_From_int((int)(wxLANGUAGE_CHINESE)));
23546 }
23547 {
23548 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SIMPLIFIED", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SIMPLIFIED)));
23549 }
23550 {
23551 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TRADITIONAL", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TRADITIONAL)));
23552 }
23553 {
23554 PyDict_SetItemString(d,"LANGUAGE_CHINESE_HONGKONG", SWIG_From_int((int)(wxLANGUAGE_CHINESE_HONGKONG)));
23555 }
23556 {
23557 PyDict_SetItemString(d,"LANGUAGE_CHINESE_MACAU", SWIG_From_int((int)(wxLANGUAGE_CHINESE_MACAU)));
23558 }
23559 {
23560 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SINGAPORE", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SINGAPORE)));
23561 }
23562 {
23563 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TAIWAN", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TAIWAN)));
23564 }
23565 {
23566 PyDict_SetItemString(d,"LANGUAGE_CORSICAN", SWIG_From_int((int)(wxLANGUAGE_CORSICAN)));
23567 }
23568 {
23569 PyDict_SetItemString(d,"LANGUAGE_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_CROATIAN)));
23570 }
23571 {
23572 PyDict_SetItemString(d,"LANGUAGE_CZECH", SWIG_From_int((int)(wxLANGUAGE_CZECH)));
23573 }
23574 {
23575 PyDict_SetItemString(d,"LANGUAGE_DANISH", SWIG_From_int((int)(wxLANGUAGE_DANISH)));
23576 }
23577 {
23578 PyDict_SetItemString(d,"LANGUAGE_DUTCH", SWIG_From_int((int)(wxLANGUAGE_DUTCH)));
23579 }
23580 {
23581 PyDict_SetItemString(d,"LANGUAGE_DUTCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_DUTCH_BELGIAN)));
23582 }
23583 {
23584 PyDict_SetItemString(d,"LANGUAGE_ENGLISH", SWIG_From_int((int)(wxLANGUAGE_ENGLISH)));
23585 }
23586 {
23587 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_UK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_UK)));
23588 }
23589 {
23590 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_US", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_US)));
23591 }
23592 {
23593 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_AUSTRALIA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_AUSTRALIA)));
23594 }
23595 {
23596 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BELIZE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BELIZE)));
23597 }
23598 {
23599 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BOTSWANA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BOTSWANA)));
23600 }
23601 {
23602 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CANADA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CANADA)));
23603 }
23604 {
23605 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CARIBBEAN", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CARIBBEAN)));
23606 }
23607 {
23608 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_DENMARK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_DENMARK)));
23609 }
23610 {
23611 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_EIRE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_EIRE)));
23612 }
23613 {
23614 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_JAMAICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_JAMAICA)));
23615 }
23616 {
23617 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_NEW_ZEALAND", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_NEW_ZEALAND)));
23618 }
23619 {
23620 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_PHILIPPINES", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_PHILIPPINES)));
23621 }
23622 {
23623 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_SOUTH_AFRICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_SOUTH_AFRICA)));
23624 }
23625 {
23626 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_TRINIDAD", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_TRINIDAD)));
23627 }
23628 {
23629 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_ZIMBABWE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_ZIMBABWE)));
23630 }
23631 {
23632 PyDict_SetItemString(d,"LANGUAGE_ESPERANTO", SWIG_From_int((int)(wxLANGUAGE_ESPERANTO)));
23633 }
23634 {
23635 PyDict_SetItemString(d,"LANGUAGE_ESTONIAN", SWIG_From_int((int)(wxLANGUAGE_ESTONIAN)));
23636 }
23637 {
23638 PyDict_SetItemString(d,"LANGUAGE_FAEROESE", SWIG_From_int((int)(wxLANGUAGE_FAEROESE)));
23639 }
23640 {
23641 PyDict_SetItemString(d,"LANGUAGE_FARSI", SWIG_From_int((int)(wxLANGUAGE_FARSI)));
23642 }
23643 {
23644 PyDict_SetItemString(d,"LANGUAGE_FIJI", SWIG_From_int((int)(wxLANGUAGE_FIJI)));
23645 }
23646 {
23647 PyDict_SetItemString(d,"LANGUAGE_FINNISH", SWIG_From_int((int)(wxLANGUAGE_FINNISH)));
23648 }
23649 {
23650 PyDict_SetItemString(d,"LANGUAGE_FRENCH", SWIG_From_int((int)(wxLANGUAGE_FRENCH)));
23651 }
23652 {
23653 PyDict_SetItemString(d,"LANGUAGE_FRENCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_BELGIAN)));
23654 }
23655 {
23656 PyDict_SetItemString(d,"LANGUAGE_FRENCH_CANADIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_CANADIAN)));
23657 }
23658 {
23659 PyDict_SetItemString(d,"LANGUAGE_FRENCH_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_FRENCH_LUXEMBOURG)));
23660 }
23661 {
23662 PyDict_SetItemString(d,"LANGUAGE_FRENCH_MONACO", SWIG_From_int((int)(wxLANGUAGE_FRENCH_MONACO)));
23663 }
23664 {
23665 PyDict_SetItemString(d,"LANGUAGE_FRENCH_SWISS", SWIG_From_int((int)(wxLANGUAGE_FRENCH_SWISS)));
23666 }
23667 {
23668 PyDict_SetItemString(d,"LANGUAGE_FRISIAN", SWIG_From_int((int)(wxLANGUAGE_FRISIAN)));
23669 }
23670 {
23671 PyDict_SetItemString(d,"LANGUAGE_GALICIAN", SWIG_From_int((int)(wxLANGUAGE_GALICIAN)));
23672 }
23673 {
23674 PyDict_SetItemString(d,"LANGUAGE_GEORGIAN", SWIG_From_int((int)(wxLANGUAGE_GEORGIAN)));
23675 }
23676 {
23677 PyDict_SetItemString(d,"LANGUAGE_GERMAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN)));
23678 }
23679 {
23680 PyDict_SetItemString(d,"LANGUAGE_GERMAN_AUSTRIAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_AUSTRIAN)));
23681 }
23682 {
23683 PyDict_SetItemString(d,"LANGUAGE_GERMAN_BELGIUM", SWIG_From_int((int)(wxLANGUAGE_GERMAN_BELGIUM)));
23684 }
23685 {
23686 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LIECHTENSTEIN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LIECHTENSTEIN)));
23687 }
23688 {
23689 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LUXEMBOURG)));
23690 }
23691 {
23692 PyDict_SetItemString(d,"LANGUAGE_GERMAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_GERMAN_SWISS)));
23693 }
23694 {
23695 PyDict_SetItemString(d,"LANGUAGE_GREEK", SWIG_From_int((int)(wxLANGUAGE_GREEK)));
23696 }
23697 {
23698 PyDict_SetItemString(d,"LANGUAGE_GREENLANDIC", SWIG_From_int((int)(wxLANGUAGE_GREENLANDIC)));
23699 }
23700 {
23701 PyDict_SetItemString(d,"LANGUAGE_GUARANI", SWIG_From_int((int)(wxLANGUAGE_GUARANI)));
23702 }
23703 {
23704 PyDict_SetItemString(d,"LANGUAGE_GUJARATI", SWIG_From_int((int)(wxLANGUAGE_GUJARATI)));
23705 }
23706 {
23707 PyDict_SetItemString(d,"LANGUAGE_HAUSA", SWIG_From_int((int)(wxLANGUAGE_HAUSA)));
23708 }
23709 {
23710 PyDict_SetItemString(d,"LANGUAGE_HEBREW", SWIG_From_int((int)(wxLANGUAGE_HEBREW)));
23711 }
23712 {
23713 PyDict_SetItemString(d,"LANGUAGE_HINDI", SWIG_From_int((int)(wxLANGUAGE_HINDI)));
23714 }
23715 {
23716 PyDict_SetItemString(d,"LANGUAGE_HUNGARIAN", SWIG_From_int((int)(wxLANGUAGE_HUNGARIAN)));
23717 }
23718 {
23719 PyDict_SetItemString(d,"LANGUAGE_ICELANDIC", SWIG_From_int((int)(wxLANGUAGE_ICELANDIC)));
23720 }
23721 {
23722 PyDict_SetItemString(d,"LANGUAGE_INDONESIAN", SWIG_From_int((int)(wxLANGUAGE_INDONESIAN)));
23723 }
23724 {
23725 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUA", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUA)));
23726 }
23727 {
23728 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUE", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUE)));
23729 }
23730 {
23731 PyDict_SetItemString(d,"LANGUAGE_INUKTITUT", SWIG_From_int((int)(wxLANGUAGE_INUKTITUT)));
23732 }
23733 {
23734 PyDict_SetItemString(d,"LANGUAGE_INUPIAK", SWIG_From_int((int)(wxLANGUAGE_INUPIAK)));
23735 }
23736 {
23737 PyDict_SetItemString(d,"LANGUAGE_IRISH", SWIG_From_int((int)(wxLANGUAGE_IRISH)));
23738 }
23739 {
23740 PyDict_SetItemString(d,"LANGUAGE_ITALIAN", SWIG_From_int((int)(wxLANGUAGE_ITALIAN)));
23741 }
23742 {
23743 PyDict_SetItemString(d,"LANGUAGE_ITALIAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_ITALIAN_SWISS)));
23744 }
23745 {
23746 PyDict_SetItemString(d,"LANGUAGE_JAPANESE", SWIG_From_int((int)(wxLANGUAGE_JAPANESE)));
23747 }
23748 {
23749 PyDict_SetItemString(d,"LANGUAGE_JAVANESE", SWIG_From_int((int)(wxLANGUAGE_JAVANESE)));
23750 }
23751 {
23752 PyDict_SetItemString(d,"LANGUAGE_KANNADA", SWIG_From_int((int)(wxLANGUAGE_KANNADA)));
23753 }
23754 {
23755 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI)));
23756 }
23757 {
23758 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI_INDIA", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI_INDIA)));
23759 }
23760 {
23761 PyDict_SetItemString(d,"LANGUAGE_KAZAKH", SWIG_From_int((int)(wxLANGUAGE_KAZAKH)));
23762 }
23763 {
23764 PyDict_SetItemString(d,"LANGUAGE_KERNEWEK", SWIG_From_int((int)(wxLANGUAGE_KERNEWEK)));
23765 }
23766 {
23767 PyDict_SetItemString(d,"LANGUAGE_KINYARWANDA", SWIG_From_int((int)(wxLANGUAGE_KINYARWANDA)));
23768 }
23769 {
23770 PyDict_SetItemString(d,"LANGUAGE_KIRGHIZ", SWIG_From_int((int)(wxLANGUAGE_KIRGHIZ)));
23771 }
23772 {
23773 PyDict_SetItemString(d,"LANGUAGE_KIRUNDI", SWIG_From_int((int)(wxLANGUAGE_KIRUNDI)));
23774 }
23775 {
23776 PyDict_SetItemString(d,"LANGUAGE_KONKANI", SWIG_From_int((int)(wxLANGUAGE_KONKANI)));
23777 }
23778 {
23779 PyDict_SetItemString(d,"LANGUAGE_KOREAN", SWIG_From_int((int)(wxLANGUAGE_KOREAN)));
23780 }
23781 {
23782 PyDict_SetItemString(d,"LANGUAGE_KURDISH", SWIG_From_int((int)(wxLANGUAGE_KURDISH)));
23783 }
23784 {
23785 PyDict_SetItemString(d,"LANGUAGE_LAOTHIAN", SWIG_From_int((int)(wxLANGUAGE_LAOTHIAN)));
23786 }
23787 {
23788 PyDict_SetItemString(d,"LANGUAGE_LATIN", SWIG_From_int((int)(wxLANGUAGE_LATIN)));
23789 }
23790 {
23791 PyDict_SetItemString(d,"LANGUAGE_LATVIAN", SWIG_From_int((int)(wxLANGUAGE_LATVIAN)));
23792 }
23793 {
23794 PyDict_SetItemString(d,"LANGUAGE_LINGALA", SWIG_From_int((int)(wxLANGUAGE_LINGALA)));
23795 }
23796 {
23797 PyDict_SetItemString(d,"LANGUAGE_LITHUANIAN", SWIG_From_int((int)(wxLANGUAGE_LITHUANIAN)));
23798 }
23799 {
23800 PyDict_SetItemString(d,"LANGUAGE_MACEDONIAN", SWIG_From_int((int)(wxLANGUAGE_MACEDONIAN)));
23801 }
23802 {
23803 PyDict_SetItemString(d,"LANGUAGE_MALAGASY", SWIG_From_int((int)(wxLANGUAGE_MALAGASY)));
23804 }
23805 {
23806 PyDict_SetItemString(d,"LANGUAGE_MALAY", SWIG_From_int((int)(wxLANGUAGE_MALAY)));
23807 }
23808 {
23809 PyDict_SetItemString(d,"LANGUAGE_MALAYALAM", SWIG_From_int((int)(wxLANGUAGE_MALAYALAM)));
23810 }
23811 {
23812 PyDict_SetItemString(d,"LANGUAGE_MALAY_BRUNEI_DARUSSALAM", SWIG_From_int((int)(wxLANGUAGE_MALAY_BRUNEI_DARUSSALAM)));
23813 }
23814 {
23815 PyDict_SetItemString(d,"LANGUAGE_MALAY_MALAYSIA", SWIG_From_int((int)(wxLANGUAGE_MALAY_MALAYSIA)));
23816 }
23817 {
23818 PyDict_SetItemString(d,"LANGUAGE_MALTESE", SWIG_From_int((int)(wxLANGUAGE_MALTESE)));
23819 }
23820 {
23821 PyDict_SetItemString(d,"LANGUAGE_MANIPURI", SWIG_From_int((int)(wxLANGUAGE_MANIPURI)));
23822 }
23823 {
23824 PyDict_SetItemString(d,"LANGUAGE_MAORI", SWIG_From_int((int)(wxLANGUAGE_MAORI)));
23825 }
23826 {
23827 PyDict_SetItemString(d,"LANGUAGE_MARATHI", SWIG_From_int((int)(wxLANGUAGE_MARATHI)));
23828 }
23829 {
23830 PyDict_SetItemString(d,"LANGUAGE_MOLDAVIAN", SWIG_From_int((int)(wxLANGUAGE_MOLDAVIAN)));
23831 }
23832 {
23833 PyDict_SetItemString(d,"LANGUAGE_MONGOLIAN", SWIG_From_int((int)(wxLANGUAGE_MONGOLIAN)));
23834 }
23835 {
23836 PyDict_SetItemString(d,"LANGUAGE_NAURU", SWIG_From_int((int)(wxLANGUAGE_NAURU)));
23837 }
23838 {
23839 PyDict_SetItemString(d,"LANGUAGE_NEPALI", SWIG_From_int((int)(wxLANGUAGE_NEPALI)));
23840 }
23841 {
23842 PyDict_SetItemString(d,"LANGUAGE_NEPALI_INDIA", SWIG_From_int((int)(wxLANGUAGE_NEPALI_INDIA)));
23843 }
23844 {
23845 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_BOKMAL", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_BOKMAL)));
23846 }
23847 {
23848 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_NYNORSK", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_NYNORSK)));
23849 }
23850 {
23851 PyDict_SetItemString(d,"LANGUAGE_OCCITAN", SWIG_From_int((int)(wxLANGUAGE_OCCITAN)));
23852 }
23853 {
23854 PyDict_SetItemString(d,"LANGUAGE_ORIYA", SWIG_From_int((int)(wxLANGUAGE_ORIYA)));
23855 }
23856 {
23857 PyDict_SetItemString(d,"LANGUAGE_OROMO", SWIG_From_int((int)(wxLANGUAGE_OROMO)));
23858 }
23859 {
23860 PyDict_SetItemString(d,"LANGUAGE_PASHTO", SWIG_From_int((int)(wxLANGUAGE_PASHTO)));
23861 }
23862 {
23863 PyDict_SetItemString(d,"LANGUAGE_POLISH", SWIG_From_int((int)(wxLANGUAGE_POLISH)));
23864 }
23865 {
23866 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE)));
23867 }
23868 {
23869 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE_BRAZILIAN", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE_BRAZILIAN)));
23870 }
23871 {
23872 PyDict_SetItemString(d,"LANGUAGE_PUNJABI", SWIG_From_int((int)(wxLANGUAGE_PUNJABI)));
23873 }
23874 {
23875 PyDict_SetItemString(d,"LANGUAGE_QUECHUA", SWIG_From_int((int)(wxLANGUAGE_QUECHUA)));
23876 }
23877 {
23878 PyDict_SetItemString(d,"LANGUAGE_RHAETO_ROMANCE", SWIG_From_int((int)(wxLANGUAGE_RHAETO_ROMANCE)));
23879 }
23880 {
23881 PyDict_SetItemString(d,"LANGUAGE_ROMANIAN", SWIG_From_int((int)(wxLANGUAGE_ROMANIAN)));
23882 }
23883 {
23884 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN)));
23885 }
23886 {
23887 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN_UKRAINE", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN_UKRAINE)));
23888 }
23889 {
23890 PyDict_SetItemString(d,"LANGUAGE_SAMOAN", SWIG_From_int((int)(wxLANGUAGE_SAMOAN)));
23891 }
23892 {
23893 PyDict_SetItemString(d,"LANGUAGE_SANGHO", SWIG_From_int((int)(wxLANGUAGE_SANGHO)));
23894 }
23895 {
23896 PyDict_SetItemString(d,"LANGUAGE_SANSKRIT", SWIG_From_int((int)(wxLANGUAGE_SANSKRIT)));
23897 }
23898 {
23899 PyDict_SetItemString(d,"LANGUAGE_SCOTS_GAELIC", SWIG_From_int((int)(wxLANGUAGE_SCOTS_GAELIC)));
23900 }
23901 {
23902 PyDict_SetItemString(d,"LANGUAGE_SERBIAN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN)));
23903 }
23904 {
23905 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_CYRILLIC)));
23906 }
23907 {
23908 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_LATIN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_LATIN)));
23909 }
23910 {
23911 PyDict_SetItemString(d,"LANGUAGE_SERBO_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_SERBO_CROATIAN)));
23912 }
23913 {
23914 PyDict_SetItemString(d,"LANGUAGE_SESOTHO", SWIG_From_int((int)(wxLANGUAGE_SESOTHO)));
23915 }
23916 {
23917 PyDict_SetItemString(d,"LANGUAGE_SETSWANA", SWIG_From_int((int)(wxLANGUAGE_SETSWANA)));
23918 }
23919 {
23920 PyDict_SetItemString(d,"LANGUAGE_SHONA", SWIG_From_int((int)(wxLANGUAGE_SHONA)));
23921 }
23922 {
23923 PyDict_SetItemString(d,"LANGUAGE_SINDHI", SWIG_From_int((int)(wxLANGUAGE_SINDHI)));
23924 }
23925 {
23926 PyDict_SetItemString(d,"LANGUAGE_SINHALESE", SWIG_From_int((int)(wxLANGUAGE_SINHALESE)));
23927 }
23928 {
23929 PyDict_SetItemString(d,"LANGUAGE_SISWATI", SWIG_From_int((int)(wxLANGUAGE_SISWATI)));
23930 }
23931 {
23932 PyDict_SetItemString(d,"LANGUAGE_SLOVAK", SWIG_From_int((int)(wxLANGUAGE_SLOVAK)));
23933 }
23934 {
23935 PyDict_SetItemString(d,"LANGUAGE_SLOVENIAN", SWIG_From_int((int)(wxLANGUAGE_SLOVENIAN)));
23936 }
23937 {
23938 PyDict_SetItemString(d,"LANGUAGE_SOMALI", SWIG_From_int((int)(wxLANGUAGE_SOMALI)));
23939 }
23940 {
23941 PyDict_SetItemString(d,"LANGUAGE_SPANISH", SWIG_From_int((int)(wxLANGUAGE_SPANISH)));
23942 }
23943 {
23944 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ARGENTINA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ARGENTINA)));
23945 }
23946 {
23947 PyDict_SetItemString(d,"LANGUAGE_SPANISH_BOLIVIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_BOLIVIA)));
23948 }
23949 {
23950 PyDict_SetItemString(d,"LANGUAGE_SPANISH_CHILE", SWIG_From_int((int)(wxLANGUAGE_SPANISH_CHILE)));
23951 }
23952 {
23953 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COLOMBIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COLOMBIA)));
23954 }
23955 {
23956 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COSTA_RICA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COSTA_RICA)));
23957 }
23958 {
23959 PyDict_SetItemString(d,"LANGUAGE_SPANISH_DOMINICAN_REPUBLIC", SWIG_From_int((int)(wxLANGUAGE_SPANISH_DOMINICAN_REPUBLIC)));
23960 }
23961 {
23962 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ECUADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ECUADOR)));
23963 }
23964 {
23965 PyDict_SetItemString(d,"LANGUAGE_SPANISH_EL_SALVADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_EL_SALVADOR)));
23966 }
23967 {
23968 PyDict_SetItemString(d,"LANGUAGE_SPANISH_GUATEMALA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_GUATEMALA)));
23969 }
23970 {
23971 PyDict_SetItemString(d,"LANGUAGE_SPANISH_HONDURAS", SWIG_From_int((int)(wxLANGUAGE_SPANISH_HONDURAS)));
23972 }
23973 {
23974 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MEXICAN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MEXICAN)));
23975 }
23976 {
23977 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MODERN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MODERN)));
23978 }
23979 {
23980 PyDict_SetItemString(d,"LANGUAGE_SPANISH_NICARAGUA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_NICARAGUA)));
23981 }
23982 {
23983 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PANAMA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PANAMA)));
23984 }
23985 {
23986 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PARAGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PARAGUAY)));
23987 }
23988 {
23989 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PERU", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PERU)));
23990 }
23991 {
23992 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PUERTO_RICO", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PUERTO_RICO)));
23993 }
23994 {
23995 PyDict_SetItemString(d,"LANGUAGE_SPANISH_URUGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_URUGUAY)));
23996 }
23997 {
23998 PyDict_SetItemString(d,"LANGUAGE_SPANISH_US", SWIG_From_int((int)(wxLANGUAGE_SPANISH_US)));
23999 }
24000 {
24001 PyDict_SetItemString(d,"LANGUAGE_SPANISH_VENEZUELA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_VENEZUELA)));
24002 }
24003 {
24004 PyDict_SetItemString(d,"LANGUAGE_SUNDANESE", SWIG_From_int((int)(wxLANGUAGE_SUNDANESE)));
24005 }
24006 {
24007 PyDict_SetItemString(d,"LANGUAGE_SWAHILI", SWIG_From_int((int)(wxLANGUAGE_SWAHILI)));
24008 }
24009 {
24010 PyDict_SetItemString(d,"LANGUAGE_SWEDISH", SWIG_From_int((int)(wxLANGUAGE_SWEDISH)));
24011 }
24012 {
24013 PyDict_SetItemString(d,"LANGUAGE_SWEDISH_FINLAND", SWIG_From_int((int)(wxLANGUAGE_SWEDISH_FINLAND)));
24014 }
24015 {
24016 PyDict_SetItemString(d,"LANGUAGE_TAGALOG", SWIG_From_int((int)(wxLANGUAGE_TAGALOG)));
24017 }
24018 {
24019 PyDict_SetItemString(d,"LANGUAGE_TAJIK", SWIG_From_int((int)(wxLANGUAGE_TAJIK)));
24020 }
24021 {
24022 PyDict_SetItemString(d,"LANGUAGE_TAMIL", SWIG_From_int((int)(wxLANGUAGE_TAMIL)));
24023 }
24024 {
24025 PyDict_SetItemString(d,"LANGUAGE_TATAR", SWIG_From_int((int)(wxLANGUAGE_TATAR)));
24026 }
24027 {
24028 PyDict_SetItemString(d,"LANGUAGE_TELUGU", SWIG_From_int((int)(wxLANGUAGE_TELUGU)));
24029 }
24030 {
24031 PyDict_SetItemString(d,"LANGUAGE_THAI", SWIG_From_int((int)(wxLANGUAGE_THAI)));
24032 }
24033 {
24034 PyDict_SetItemString(d,"LANGUAGE_TIBETAN", SWIG_From_int((int)(wxLANGUAGE_TIBETAN)));
24035 }
24036 {
24037 PyDict_SetItemString(d,"LANGUAGE_TIGRINYA", SWIG_From_int((int)(wxLANGUAGE_TIGRINYA)));
24038 }
24039 {
24040 PyDict_SetItemString(d,"LANGUAGE_TONGA", SWIG_From_int((int)(wxLANGUAGE_TONGA)));
24041 }
24042 {
24043 PyDict_SetItemString(d,"LANGUAGE_TSONGA", SWIG_From_int((int)(wxLANGUAGE_TSONGA)));
24044 }
24045 {
24046 PyDict_SetItemString(d,"LANGUAGE_TURKISH", SWIG_From_int((int)(wxLANGUAGE_TURKISH)));
24047 }
24048 {
24049 PyDict_SetItemString(d,"LANGUAGE_TURKMEN", SWIG_From_int((int)(wxLANGUAGE_TURKMEN)));
24050 }
24051 {
24052 PyDict_SetItemString(d,"LANGUAGE_TWI", SWIG_From_int((int)(wxLANGUAGE_TWI)));
24053 }
24054 {
24055 PyDict_SetItemString(d,"LANGUAGE_UIGHUR", SWIG_From_int((int)(wxLANGUAGE_UIGHUR)));
24056 }
24057 {
24058 PyDict_SetItemString(d,"LANGUAGE_UKRAINIAN", SWIG_From_int((int)(wxLANGUAGE_UKRAINIAN)));
24059 }
24060 {
24061 PyDict_SetItemString(d,"LANGUAGE_URDU", SWIG_From_int((int)(wxLANGUAGE_URDU)));
24062 }
24063 {
24064 PyDict_SetItemString(d,"LANGUAGE_URDU_INDIA", SWIG_From_int((int)(wxLANGUAGE_URDU_INDIA)));
24065 }
24066 {
24067 PyDict_SetItemString(d,"LANGUAGE_URDU_PAKISTAN", SWIG_From_int((int)(wxLANGUAGE_URDU_PAKISTAN)));
24068 }
24069 {
24070 PyDict_SetItemString(d,"LANGUAGE_UZBEK", SWIG_From_int((int)(wxLANGUAGE_UZBEK)));
24071 }
24072 {
24073 PyDict_SetItemString(d,"LANGUAGE_UZBEK_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_UZBEK_CYRILLIC)));
24074 }
24075 {
24076 PyDict_SetItemString(d,"LANGUAGE_UZBEK_LATIN", SWIG_From_int((int)(wxLANGUAGE_UZBEK_LATIN)));
24077 }
24078 {
24079 PyDict_SetItemString(d,"LANGUAGE_VIETNAMESE", SWIG_From_int((int)(wxLANGUAGE_VIETNAMESE)));
24080 }
24081 {
24082 PyDict_SetItemString(d,"LANGUAGE_VOLAPUK", SWIG_From_int((int)(wxLANGUAGE_VOLAPUK)));
24083 }
24084 {
24085 PyDict_SetItemString(d,"LANGUAGE_WELSH", SWIG_From_int((int)(wxLANGUAGE_WELSH)));
24086 }
24087 {
24088 PyDict_SetItemString(d,"LANGUAGE_WOLOF", SWIG_From_int((int)(wxLANGUAGE_WOLOF)));
24089 }
24090 {
24091 PyDict_SetItemString(d,"LANGUAGE_XHOSA", SWIG_From_int((int)(wxLANGUAGE_XHOSA)));
24092 }
24093 {
24094 PyDict_SetItemString(d,"LANGUAGE_YIDDISH", SWIG_From_int((int)(wxLANGUAGE_YIDDISH)));
24095 }
24096 {
24097 PyDict_SetItemString(d,"LANGUAGE_YORUBA", SWIG_From_int((int)(wxLANGUAGE_YORUBA)));
24098 }
24099 {
24100 PyDict_SetItemString(d,"LANGUAGE_ZHUANG", SWIG_From_int((int)(wxLANGUAGE_ZHUANG)));
24101 }
24102 {
24103 PyDict_SetItemString(d,"LANGUAGE_ZULU", SWIG_From_int((int)(wxLANGUAGE_ZULU)));
24104 }
24105 {
24106 PyDict_SetItemString(d,"LANGUAGE_USER_DEFINED", SWIG_From_int((int)(wxLANGUAGE_USER_DEFINED)));
24107 }
24108 {
24109 PyDict_SetItemString(d,"LOCALE_CAT_NUMBER", SWIG_From_int((int)(wxLOCALE_CAT_NUMBER)));
24110 }
24111 {
24112 PyDict_SetItemString(d,"LOCALE_CAT_DATE", SWIG_From_int((int)(wxLOCALE_CAT_DATE)));
24113 }
24114 {
24115 PyDict_SetItemString(d,"LOCALE_CAT_MONEY", SWIG_From_int((int)(wxLOCALE_CAT_MONEY)));
24116 }
24117 {
24118 PyDict_SetItemString(d,"LOCALE_CAT_MAX", SWIG_From_int((int)(wxLOCALE_CAT_MAX)));
24119 }
24120 {
24121 PyDict_SetItemString(d,"LOCALE_THOUSANDS_SEP", SWIG_From_int((int)(wxLOCALE_THOUSANDS_SEP)));
24122 }
24123 {
24124 PyDict_SetItemString(d,"LOCALE_DECIMAL_POINT", SWIG_From_int((int)(wxLOCALE_DECIMAL_POINT)));
24125 }
24126 {
24127 PyDict_SetItemString(d,"LOCALE_LOAD_DEFAULT", SWIG_From_int((int)(wxLOCALE_LOAD_DEFAULT)));
24128 }
24129 {
24130 PyDict_SetItemString(d,"LOCALE_CONV_ENCODING", SWIG_From_int((int)(wxLOCALE_CONV_ENCODING)));
24131 }
24132 {
24133 PyDict_SetItemString(d,"CONVERT_STRICT", SWIG_From_int((int)(wxCONVERT_STRICT)));
24134 }
24135 {
24136 PyDict_SetItemString(d,"CONVERT_SUBSTITUTE", SWIG_From_int((int)(wxCONVERT_SUBSTITUTE)));
24137 }
24138 {
24139 PyDict_SetItemString(d,"PLATFORM_CURRENT", SWIG_From_int((int)(wxPLATFORM_CURRENT)));
24140 }
24141 {
24142 PyDict_SetItemString(d,"PLATFORM_UNIX", SWIG_From_int((int)(wxPLATFORM_UNIX)));
24143 }
24144 {
24145 PyDict_SetItemString(d,"PLATFORM_WINDOWS", SWIG_From_int((int)(wxPLATFORM_WINDOWS)));
24146 }
24147 {
24148 PyDict_SetItemString(d,"PLATFORM_OS2", SWIG_From_int((int)(wxPLATFORM_OS2)));
24149 }
24150 {
24151 PyDict_SetItemString(d,"PLATFORM_MAC", SWIG_From_int((int)(wxPLATFORM_MAC)));
24152 }
24153 {
24154 PyDict_SetItemString(d,"BUFFER_VIRTUAL_AREA", SWIG_From_int((int)(wxBUFFER_VIRTUAL_AREA)));
24155 }
24156 {
24157 PyDict_SetItemString(d,"BUFFER_CLIENT_AREA", SWIG_From_int((int)(wxBUFFER_CLIENT_AREA)));
24158 }
24159 {
24160 PyDict_SetItemString(d,"IMAGELIST_DRAW_NORMAL", SWIG_From_int((int)(wxIMAGELIST_DRAW_NORMAL)));
24161 }
24162 {
24163 PyDict_SetItemString(d,"IMAGELIST_DRAW_TRANSPARENT", SWIG_From_int((int)(wxIMAGELIST_DRAW_TRANSPARENT)));
24164 }
24165 {
24166 PyDict_SetItemString(d,"IMAGELIST_DRAW_SELECTED", SWIG_From_int((int)(wxIMAGELIST_DRAW_SELECTED)));
24167 }
24168 {
24169 PyDict_SetItemString(d,"IMAGELIST_DRAW_FOCUSED", SWIG_From_int((int)(wxIMAGELIST_DRAW_FOCUSED)));
24170 }
24171 {
24172 PyDict_SetItemString(d,"IMAGE_LIST_NORMAL", SWIG_From_int((int)(wxIMAGE_LIST_NORMAL)));
24173 }
24174 {
24175 PyDict_SetItemString(d,"IMAGE_LIST_SMALL", SWIG_From_int((int)(wxIMAGE_LIST_SMALL)));
24176 }
24177 {
24178 PyDict_SetItemString(d,"IMAGE_LIST_STATE", SWIG_From_int((int)(wxIMAGE_LIST_STATE)));
24179 }
24180 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
24181 SWIG_addvarlink(SWIG_globals,(char*)"NORMAL_FONT",_wrap_NORMAL_FONT_get, _wrap_NORMAL_FONT_set);
24182 SWIG_addvarlink(SWIG_globals,(char*)"SMALL_FONT",_wrap_SMALL_FONT_get, _wrap_SMALL_FONT_set);
24183 SWIG_addvarlink(SWIG_globals,(char*)"ITALIC_FONT",_wrap_ITALIC_FONT_get, _wrap_ITALIC_FONT_set);
24184 SWIG_addvarlink(SWIG_globals,(char*)"SWISS_FONT",_wrap_SWISS_FONT_get, _wrap_SWISS_FONT_set);
24185 SWIG_addvarlink(SWIG_globals,(char*)"RED_PEN",_wrap_RED_PEN_get, _wrap_RED_PEN_set);
24186 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_PEN",_wrap_CYAN_PEN_get, _wrap_CYAN_PEN_set);
24187 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_PEN",_wrap_GREEN_PEN_get, _wrap_GREEN_PEN_set);
24188 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_PEN",_wrap_BLACK_PEN_get, _wrap_BLACK_PEN_set);
24189 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_PEN",_wrap_WHITE_PEN_get, _wrap_WHITE_PEN_set);
24190 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_PEN",_wrap_TRANSPARENT_PEN_get, _wrap_TRANSPARENT_PEN_set);
24191 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_DASHED_PEN",_wrap_BLACK_DASHED_PEN_get, _wrap_BLACK_DASHED_PEN_set);
24192 SWIG_addvarlink(SWIG_globals,(char*)"GREY_PEN",_wrap_GREY_PEN_get, _wrap_GREY_PEN_set);
24193 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_PEN",_wrap_MEDIUM_GREY_PEN_get, _wrap_MEDIUM_GREY_PEN_set);
24194 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_PEN",_wrap_LIGHT_GREY_PEN_get, _wrap_LIGHT_GREY_PEN_set);
24195 SWIG_addvarlink(SWIG_globals,(char*)"BLUE_BRUSH",_wrap_BLUE_BRUSH_get, _wrap_BLUE_BRUSH_set);
24196 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_BRUSH",_wrap_GREEN_BRUSH_get, _wrap_GREEN_BRUSH_set);
24197 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_BRUSH",_wrap_WHITE_BRUSH_get, _wrap_WHITE_BRUSH_set);
24198 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_BRUSH",_wrap_BLACK_BRUSH_get, _wrap_BLACK_BRUSH_set);
24199 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_BRUSH",_wrap_TRANSPARENT_BRUSH_get, _wrap_TRANSPARENT_BRUSH_set);
24200 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_BRUSH",_wrap_CYAN_BRUSH_get, _wrap_CYAN_BRUSH_set);
24201 SWIG_addvarlink(SWIG_globals,(char*)"RED_BRUSH",_wrap_RED_BRUSH_get, _wrap_RED_BRUSH_set);
24202 SWIG_addvarlink(SWIG_globals,(char*)"GREY_BRUSH",_wrap_GREY_BRUSH_get, _wrap_GREY_BRUSH_set);
24203 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_BRUSH",_wrap_MEDIUM_GREY_BRUSH_get, _wrap_MEDIUM_GREY_BRUSH_set);
24204 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_BRUSH",_wrap_LIGHT_GREY_BRUSH_get, _wrap_LIGHT_GREY_BRUSH_set);
24205 SWIG_addvarlink(SWIG_globals,(char*)"BLACK",_wrap_BLACK_get, _wrap_BLACK_set);
24206 SWIG_addvarlink(SWIG_globals,(char*)"WHITE",_wrap_WHITE_get, _wrap_WHITE_set);
24207 SWIG_addvarlink(SWIG_globals,(char*)"RED",_wrap_RED_get, _wrap_RED_set);
24208 SWIG_addvarlink(SWIG_globals,(char*)"BLUE",_wrap_BLUE_get, _wrap_BLUE_set);
24209 SWIG_addvarlink(SWIG_globals,(char*)"GREEN",_wrap_GREEN_get, _wrap_GREEN_set);
24210 SWIG_addvarlink(SWIG_globals,(char*)"CYAN",_wrap_CYAN_get, _wrap_CYAN_set);
24211 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY",_wrap_LIGHT_GREY_get, _wrap_LIGHT_GREY_set);
24212 SWIG_addvarlink(SWIG_globals,(char*)"STANDARD_CURSOR",_wrap_STANDARD_CURSOR_get, _wrap_STANDARD_CURSOR_set);
24213 SWIG_addvarlink(SWIG_globals,(char*)"HOURGLASS_CURSOR",_wrap_HOURGLASS_CURSOR_get, _wrap_HOURGLASS_CURSOR_set);
24214 SWIG_addvarlink(SWIG_globals,(char*)"CROSS_CURSOR",_wrap_CROSS_CURSOR_get, _wrap_CROSS_CURSOR_set);
24215 SWIG_addvarlink(SWIG_globals,(char*)"NullBitmap",_wrap_NullBitmap_get, _wrap_NullBitmap_set);
24216 SWIG_addvarlink(SWIG_globals,(char*)"NullIcon",_wrap_NullIcon_get, _wrap_NullIcon_set);
24217 SWIG_addvarlink(SWIG_globals,(char*)"NullCursor",_wrap_NullCursor_get, _wrap_NullCursor_set);
24218 SWIG_addvarlink(SWIG_globals,(char*)"NullPen",_wrap_NullPen_get, _wrap_NullPen_set);
24219 SWIG_addvarlink(SWIG_globals,(char*)"NullBrush",_wrap_NullBrush_get, _wrap_NullBrush_set);
24220 SWIG_addvarlink(SWIG_globals,(char*)"NullPalette",_wrap_NullPalette_get, _wrap_NullPalette_set);
24221 SWIG_addvarlink(SWIG_globals,(char*)"NullFont",_wrap_NullFont_get, _wrap_NullFont_set);
24222 SWIG_addvarlink(SWIG_globals,(char*)"NullColour",_wrap_NullColour_get, _wrap_NullColour_set);
24223 SWIG_addvarlink(SWIG_globals,(char*)"TheFontList",_wrap_TheFontList_get, _wrap_TheFontList_set);
24224 SWIG_addvarlink(SWIG_globals,(char*)"ThePenList",_wrap_ThePenList_get, _wrap_ThePenList_set);
24225 SWIG_addvarlink(SWIG_globals,(char*)"TheBrushList",_wrap_TheBrushList_get, _wrap_TheBrushList_set);
24226 SWIG_addvarlink(SWIG_globals,(char*)"TheColourDatabase",_wrap_TheColourDatabase_get, _wrap_TheColourDatabase_set);
24227 {
24228 PyDict_SetItemString(d,"CONTROL_DISABLED", SWIG_From_int((int)(wxCONTROL_DISABLED)));
24229 }
24230 {
24231 PyDict_SetItemString(d,"CONTROL_FOCUSED", SWIG_From_int((int)(wxCONTROL_FOCUSED)));
24232 }
24233 {
24234 PyDict_SetItemString(d,"CONTROL_PRESSED", SWIG_From_int((int)(wxCONTROL_PRESSED)));
24235 }
24236 {
24237 PyDict_SetItemString(d,"CONTROL_ISDEFAULT", SWIG_From_int((int)(wxCONTROL_ISDEFAULT)));
24238 }
24239 {
24240 PyDict_SetItemString(d,"CONTROL_ISSUBMENU", SWIG_From_int((int)(wxCONTROL_ISSUBMENU)));
24241 }
24242 {
24243 PyDict_SetItemString(d,"CONTROL_EXPANDED", SWIG_From_int((int)(wxCONTROL_EXPANDED)));
24244 }
24245 {
24246 PyDict_SetItemString(d,"CONTROL_CURRENT", SWIG_From_int((int)(wxCONTROL_CURRENT)));
24247 }
24248 {
24249 PyDict_SetItemString(d,"CONTROL_SELECTED", SWIG_From_int((int)(wxCONTROL_SELECTED)));
24250 }
24251 {
24252 PyDict_SetItemString(d,"CONTROL_CHECKED", SWIG_From_int((int)(wxCONTROL_CHECKED)));
24253 }
24254 {
24255 PyDict_SetItemString(d,"CONTROL_CHECKABLE", SWIG_From_int((int)(wxCONTROL_CHECKABLE)));
24256 }
24257 {
24258 PyDict_SetItemString(d,"CONTROL_UNDETERMINED", SWIG_From_int((int)(wxCONTROL_UNDETERMINED)));
24259 }
24260 {
24261 PyDict_SetItemString(d,"CONTROL_FLAGS_MASK", SWIG_From_int((int)(wxCONTROL_FLAGS_MASK)));
24262 }
24263 {
24264 PyDict_SetItemString(d,"CONTROL_DIRTY", SWIG_From_int((int)(wxCONTROL_DIRTY)));
24265 }
24266 {
24267 PyDict_SetItemString(d,"RendererVersion_Current_Version", SWIG_From_int((int)(wxRendererVersion::Current_Version)));
24268 }
24269 {
24270 PyDict_SetItemString(d,"RendererVersion_Current_Age", SWIG_From_int((int)(wxRendererVersion::Current_Age)));
24271 }
24272
24273 // Work around a chicken/egg problem in drawlist.cpp
24274 wxPyDrawList_SetAPIPtr();
24275
24276 }
24277
wxWidgets (Impactor)