]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_gdi_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Fix shift and other keys with wxGetKeyState on mac
[wxWidgets.git] / wxPython / src / msw / _gdi_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 if (str)
1041 Py_DECREF(str);
1042 return;
1043 }
1044 }
1045 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1046 } else {
1047 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1048 }
1049 }
1050
1051 SWIGRUNTIMEINLINE void
1052 SWIG_Python_NullRef(const char *type)
1053 {
1054 if (type) {
1055 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1056 } else {
1057 PyErr_Format(PyExc_TypeError, "null reference was received");
1058 }
1059 }
1060
1061 SWIGRUNTIME int
1062 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1063 {
1064 if (PyErr_Occurred()) {
1065 PyObject *type = 0;
1066 PyObject *value = 0;
1067 PyObject *traceback = 0;
1068 PyErr_Fetch(&type, &value, &traceback);
1069 if (value) {
1070 PyObject *old_str = PyObject_Str(value);
1071 Py_XINCREF(type);
1072 PyErr_Clear();
1073 if (infront) {
1074 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1075 } else {
1076 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1077 }
1078 Py_DECREF(old_str);
1079 }
1080 return 1;
1081 } else {
1082 return 0;
1083 }
1084 }
1085
1086 SWIGRUNTIME int
1087 SWIG_Python_ArgFail(int argnum)
1088 {
1089 if (PyErr_Occurred()) {
1090 /* add information about failing argument */
1091 char mesg[256];
1092 sprintf(mesg, "argument number %d:", argnum);
1093 return SWIG_Python_AddErrMesg(mesg, 1);
1094 } else {
1095 return 0;
1096 }
1097 }
1098
1099
1100 /* -----------------------------------------------------------------------------
1101 * pointers/data manipulation
1102 * ----------------------------------------------------------------------------- */
1103
1104 /* Convert a pointer value */
1105 SWIGRUNTIME int
1106 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1107 swig_type_info *tc;
1108 const char *c = 0;
1109 static PyObject *SWIG_this = 0;
1110 int newref = 0;
1111 PyObject *pyobj = 0;
1112 void *vptr;
1113
1114 if (!obj) return 0;
1115 if (obj == Py_None) {
1116 *ptr = 0;
1117 return 0;
1118 }
1119
1120 #ifdef SWIG_COBJECT_TYPES
1121 if (!(PySwigObject_Check(obj))) {
1122 if (!SWIG_this)
1123 SWIG_this = PyString_FromString("this");
1124 pyobj = obj;
1125 obj = PyObject_GetAttr(obj,SWIG_this);
1126 newref = 1;
1127 if (!obj) goto type_error;
1128 if (!PySwigObject_Check(obj)) {
1129 Py_DECREF(obj);
1130 goto type_error;
1131 }
1132 }
1133 vptr = PySwigObject_AsVoidPtr(obj);
1134 c = (const char *) PySwigObject_GetDesc(obj);
1135 if (newref) { Py_DECREF(obj); }
1136 goto type_check;
1137 #else
1138 if (!(PyString_Check(obj))) {
1139 if (!SWIG_this)
1140 SWIG_this = PyString_FromString("this");
1141 pyobj = obj;
1142 obj = PyObject_GetAttr(obj,SWIG_this);
1143 newref = 1;
1144 if (!obj) goto type_error;
1145 if (!PyString_Check(obj)) {
1146 Py_DECREF(obj);
1147 goto type_error;
1148 }
1149 }
1150 c = PyString_AS_STRING(obj);
1151 /* Pointer values must start with leading underscore */
1152 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1153 if (newref) { Py_DECREF(obj); }
1154 if (!c) goto type_error;
1155 #endif
1156
1157 type_check:
1158
1159 if (ty) {
1160 tc = SWIG_TypeCheck(c,ty);
1161 if (!tc) goto type_error;
1162 *ptr = SWIG_TypeCast(tc,vptr);
1163 } else {
1164 *ptr = vptr;
1165 }
1166
1167 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1168 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1169 }
1170 return 0;
1171
1172 type_error:
1173 PyErr_Clear();
1174 if (pyobj && !obj) {
1175 obj = pyobj;
1176 if (PyCFunction_Check(obj)) {
1177 /* here we get the method pointer for callbacks */
1178 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1179 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1180 if (c) {
1181 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1182 if (!c) goto type_error;
1183 goto type_check;
1184 }
1185 }
1186 }
1187 if (flags & SWIG_POINTER_EXCEPTION) {
1188 if (ty) {
1189 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1190 } else {
1191 SWIG_Python_TypeError("C/C++ pointer", obj);
1192 }
1193 }
1194 return -1;
1195 }
1196
1197 /* Convert a pointer value, signal an exception on a type mismatch */
1198 SWIGRUNTIME void *
1199 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1200 void *result;
1201 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1202 PyErr_Clear();
1203 if (flags & SWIG_POINTER_EXCEPTION) {
1204 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1205 SWIG_Python_ArgFail(argnum);
1206 }
1207 }
1208 return result;
1209 }
1210
1211 /* Convert a packed value value */
1212 SWIGRUNTIME int
1213 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1214 swig_type_info *tc;
1215 const char *c = 0;
1216
1217 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1218 c = PySwigPacked_UnpackData(obj, ptr, sz);
1219 #else
1220 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1221 c = PyString_AS_STRING(obj);
1222 /* Pointer values must start with leading underscore */
1223 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1224 #endif
1225 if (!c) goto type_error;
1226 if (ty) {
1227 tc = SWIG_TypeCheck(c,ty);
1228 if (!tc) goto type_error;
1229 }
1230 return 0;
1231
1232 type_error:
1233 PyErr_Clear();
1234 if (flags & SWIG_POINTER_EXCEPTION) {
1235 if (ty) {
1236 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1237 } else {
1238 SWIG_Python_TypeError("C/C++ packed data", obj);
1239 }
1240 }
1241 return -1;
1242 }
1243
1244 /* Create a new array object */
1245 SWIGRUNTIME PyObject *
1246 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1247 PyObject *robj = 0;
1248 if (!ptr) {
1249 Py_INCREF(Py_None);
1250 return Py_None;
1251 }
1252 #ifdef SWIG_COBJECT_TYPES
1253 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1254 #else
1255 {
1256 char result[SWIG_BUFFER_SIZE];
1257 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1258 PyString_FromString(result) : 0;
1259 }
1260 #endif
1261 if (!robj || (robj == Py_None)) return robj;
1262 if (type->clientdata) {
1263 PyObject *inst;
1264 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1265 Py_DECREF(robj);
1266 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1267 Py_DECREF(args);
1268 if (inst) {
1269 if (own) {
1270 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1271 }
1272 robj = inst;
1273 }
1274 }
1275 return robj;
1276 }
1277
1278 SWIGRUNTIME PyObject *
1279 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1280 PyObject *robj = 0;
1281 if (!ptr) {
1282 Py_INCREF(Py_None);
1283 return Py_None;
1284 }
1285 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1286 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1287 #else
1288 {
1289 char result[SWIG_BUFFER_SIZE];
1290 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1291 PyString_FromString(result) : 0;
1292 }
1293 #endif
1294 return robj;
1295 }
1296
1297 /* -----------------------------------------------------------------------------*
1298 * Get type list
1299 * -----------------------------------------------------------------------------*/
1300
1301 #ifdef SWIG_LINK_RUNTIME
1302 void *SWIG_ReturnGlobalTypeList(void *);
1303 #endif
1304
1305 SWIGRUNTIME swig_type_info **
1306 SWIG_Python_GetTypeListHandle() {
1307 static void *type_pointer = (void *)0;
1308 /* first check if module already created */
1309 if (!type_pointer) {
1310 #ifdef SWIG_LINK_RUNTIME
1311 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1312 #else
1313 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1314 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1315 if (PyErr_Occurred()) {
1316 PyErr_Clear();
1317 type_pointer = (void *)0;
1318 }
1319 }
1320 #endif
1321 return (swig_type_info **) type_pointer;
1322 }
1323
1324 /*
1325 Search for a swig_type_info structure
1326 */
1327 SWIGRUNTIMEINLINE swig_type_info *
1328 SWIG_Python_GetTypeList() {
1329 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1330 return tlh ? *tlh : (swig_type_info*)0;
1331 }
1332
1333 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1334
1335 #ifdef __cplusplus
1336 }
1337 #endif
1338
1339
1340 /* -------- TYPES TABLE (BEGIN) -------- */
1341
1342 #define SWIGTYPE_p_wxPostScriptDC swig_types[0]
1343 #define SWIGTYPE_p_wxBrush swig_types[1]
1344 #define SWIGTYPE_p_wxColour swig_types[2]
1345 #define SWIGTYPE_p_wxDC swig_types[3]
1346 #define SWIGTYPE_p_wxMirrorDC swig_types[4]
1347 #define SWIGTYPE_p_form_ops_t swig_types[5]
1348 #define SWIGTYPE_p_wxDuplexMode swig_types[6]
1349 #define SWIGTYPE_p_wxPyFontEnumerator swig_types[7]
1350 #define SWIGTYPE_p_char swig_types[8]
1351 #define SWIGTYPE_p_wxIconLocation swig_types[9]
1352 #define SWIGTYPE_p_wxImage swig_types[10]
1353 #define SWIGTYPE_p_wxMetaFileDC swig_types[11]
1354 #define SWIGTYPE_p_wxMask swig_types[12]
1355 #define SWIGTYPE_p_wxSize swig_types[13]
1356 #define SWIGTYPE_p_wxFont swig_types[14]
1357 #define SWIGTYPE_p_wxWindow swig_types[15]
1358 #define SWIGTYPE_p_double swig_types[16]
1359 #define SWIGTYPE_p_wxMemoryDC swig_types[17]
1360 #define SWIGTYPE_p_wxFontMapper swig_types[18]
1361 #define SWIGTYPE_p_wxEffects swig_types[19]
1362 #define SWIGTYPE_p_wxNativeEncodingInfo swig_types[20]
1363 #define SWIGTYPE_p_wxPalette swig_types[21]
1364 #define SWIGTYPE_p_wxBitmap swig_types[22]
1365 #define SWIGTYPE_p_wxObject swig_types[23]
1366 #define SWIGTYPE_p_wxRegionIterator swig_types[24]
1367 #define SWIGTYPE_p_wxRect swig_types[25]
1368 #define SWIGTYPE_p_wxPaperSize swig_types[26]
1369 #define SWIGTYPE_p_wxString swig_types[27]
1370 #define SWIGTYPE_unsigned_int swig_types[28]
1371 #define SWIGTYPE_p_unsigned_int swig_types[29]
1372 #define SWIGTYPE_p_wxPrinterDC swig_types[30]
1373 #define SWIGTYPE_p_wxIconBundle swig_types[31]
1374 #define SWIGTYPE_p_wxPoint swig_types[32]
1375 #define SWIGTYPE_p_wxDash swig_types[33]
1376 #define SWIGTYPE_p_wxScreenDC swig_types[34]
1377 #define SWIGTYPE_p_wxCursor swig_types[35]
1378 #define SWIGTYPE_p_wxClientDC swig_types[36]
1379 #define SWIGTYPE_p_wxBufferedDC swig_types[37]
1380 #define SWIGTYPE_p_wxImageList swig_types[38]
1381 #define SWIGTYPE_p_unsigned_char swig_types[39]
1382 #define SWIGTYPE_p_wxGDIObject swig_types[40]
1383 #define SWIGTYPE_p_wxIcon swig_types[41]
1384 #define SWIGTYPE_p_wxLocale swig_types[42]
1385 #define SWIGTYPE_ptrdiff_t swig_types[43]
1386 #define SWIGTYPE_std__ptrdiff_t swig_types[44]
1387 #define SWIGTYPE_p_wxRegion swig_types[45]
1388 #define SWIGTYPE_p_wxConfigBase swig_types[46]
1389 #define SWIGTYPE_p_wxLanguageInfo swig_types[47]
1390 #define SWIGTYPE_p_wxWindowDC swig_types[48]
1391 #define SWIGTYPE_p_wxPrintData swig_types[49]
1392 #define SWIGTYPE_p_wxBrushList swig_types[50]
1393 #define SWIGTYPE_p_wxFontList swig_types[51]
1394 #define SWIGTYPE_p_wxPen swig_types[52]
1395 #define SWIGTYPE_p_wxBufferedPaintDC swig_types[53]
1396 #define SWIGTYPE_p_wxPaintDC swig_types[54]
1397 #define SWIGTYPE_p_wxPenList swig_types[55]
1398 #define SWIGTYPE_p_int swig_types[56]
1399 #define SWIGTYPE_p_wxMetaFile swig_types[57]
1400 #define SWIGTYPE_p_unsigned_long swig_types[58]
1401 #define SWIGTYPE_p_wxNativeFontInfo swig_types[59]
1402 #define SWIGTYPE_p_wxEncodingConverter swig_types[60]
1403 #define SWIGTYPE_p_wxColourDatabase swig_types[61]
1404 static swig_type_info *swig_types[63];
1405
1406 /* -------- TYPES TABLE (END) -------- */
1407
1408
1409 /*-----------------------------------------------
1410 @(target):= _gdi_.so
1411 ------------------------------------------------*/
1412 #define SWIG_init init_gdi_
1413
1414 #define SWIG_name "_gdi_"
1415
1416 #include "wx/wxPython/wxPython.h"
1417 #include "wx/wxPython/pyclasses.h"
1418
1419
1420 static const wxString wxPyEmptyString(wxEmptyString);
1421
1422 #include <limits.h>
1423
1424
1425 SWIGINTERN int
1426 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1427 const char *errmsg)
1428 {
1429 if (value < min_value) {
1430 if (errmsg) {
1431 PyErr_Format(PyExc_OverflowError,
1432 "value %ld is less than '%s' minimum %ld",
1433 value, errmsg, min_value);
1434 }
1435 return 0;
1436 } else if (value > max_value) {
1437 if (errmsg) {
1438 PyErr_Format(PyExc_OverflowError,
1439 "value %ld is greater than '%s' maximum %ld",
1440 value, errmsg, max_value);
1441 }
1442 return 0;
1443 }
1444 return 1;
1445 }
1446
1447
1448 SWIGINTERN int
1449 SWIG_AsVal_long(PyObject* obj, long* val)
1450 {
1451 if (PyNumber_Check(obj)) {
1452 if (val) *val = PyInt_AsLong(obj);
1453 return 1;
1454 }
1455 else {
1456 SWIG_type_error("number", obj);
1457 }
1458 return 0;
1459 }
1460
1461
1462 #if INT_MAX != LONG_MAX
1463 SWIGINTERN int
1464 SWIG_AsVal_int(PyObject *obj, int *val)
1465 {
1466 const char* errmsg = val ? "int" : (char*)0;
1467 long v;
1468 if (SWIG_AsVal_long(obj, &v)) {
1469 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1470 if (val) *val = (int)(v);
1471 return 1;
1472 } else {
1473 return 0;
1474 }
1475 } else {
1476 PyErr_Clear();
1477 }
1478 if (val) {
1479 SWIG_type_error(errmsg, obj);
1480 }
1481 return 0;
1482 }
1483 #else
1484 SWIGINTERNSHORT int
1485 SWIG_AsVal_int(PyObject *obj, int *val)
1486 {
1487 return SWIG_AsVal_long(obj,(long*)val);
1488 }
1489 #endif
1490
1491
1492 SWIGINTERN int
1493 SWIG_AsVal_bool(PyObject *obj, bool *val)
1494 {
1495 if (obj == Py_True) {
1496 if (val) *val = true;
1497 return 1;
1498 }
1499 if (obj == Py_False) {
1500 if (val) *val = false;
1501 return 1;
1502 }
1503 int res = 0;
1504 if (SWIG_AsVal_int(obj, &res)) {
1505 if (val) *val = res ? true : false;
1506 return 1;
1507 } else {
1508 PyErr_Clear();
1509 }
1510 if (val) {
1511 SWIG_type_error("bool", obj);
1512 }
1513 return 0;
1514 }
1515
1516
1517 SWIGINTERNSHORT bool
1518 SWIG_As_bool(PyObject* obj)
1519 {
1520 bool v;
1521 if (!SWIG_AsVal_bool(obj, &v)) {
1522 /*
1523 this is needed to make valgrind/purify happier.
1524 */
1525 memset((void*)&v, 0, sizeof(bool));
1526 }
1527 return v;
1528 }
1529
1530
1531 SWIGINTERNSHORT int
1532 SWIG_Check_bool(PyObject* obj)
1533 {
1534 return SWIG_AsVal_bool(obj, (bool*)0);
1535 }
1536
1537
1538 SWIGINTERN int
1539 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1540 {
1541 long v = 0;
1542 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1543 SWIG_type_error("unsigned number", obj);
1544 }
1545 else if (val)
1546 *val = (unsigned long)v;
1547 return 1;
1548 }
1549
1550
1551 SWIGINTERNSHORT int
1552 SWIG_CheckUnsignedLongInRange(unsigned long value,
1553 unsigned long max_value,
1554 const char *errmsg)
1555 {
1556 if (value > max_value) {
1557 if (errmsg) {
1558 PyErr_Format(PyExc_OverflowError,
1559 "value %lu is greater than '%s' minimum %lu",
1560 value, errmsg, max_value);
1561 }
1562 return 0;
1563 }
1564 return 1;
1565 }
1566
1567
1568 SWIGINTERN int
1569 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
1570 {
1571 const char* errmsg = val ? "unsigned char" : (char*)0;
1572 unsigned long v;
1573 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1574 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
1575 if (val) *val = (unsigned char)(v);
1576 return 1;
1577 } else {
1578 return 0;
1579 }
1580 } else {
1581 PyErr_Clear();
1582 }
1583 if (val) {
1584 SWIG_type_error(errmsg, obj);
1585 }
1586 return 0;
1587 }
1588
1589
1590 SWIGINTERNSHORT unsigned char
1591 SWIG_As_unsigned_SS_char(PyObject* obj)
1592 {
1593 unsigned char v;
1594 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
1595 /*
1596 this is needed to make valgrind/purify happier.
1597 */
1598 memset((void*)&v, 0, sizeof(unsigned char));
1599 }
1600 return v;
1601 }
1602
1603
1604 SWIGINTERNSHORT int
1605 SWIG_Check_unsigned_SS_char(PyObject* obj)
1606 {
1607 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
1608 }
1609
1610
1611 SWIGINTERNSHORT unsigned long
1612 SWIG_As_unsigned_SS_long(PyObject* obj)
1613 {
1614 unsigned long v;
1615 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1616 /*
1617 this is needed to make valgrind/purify happier.
1618 */
1619 memset((void*)&v, 0, sizeof(unsigned long));
1620 }
1621 return v;
1622 }
1623
1624
1625 SWIGINTERNSHORT int
1626 SWIG_Check_unsigned_SS_long(PyObject* obj)
1627 {
1628 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1629 }
1630
1631
1632 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1633 #define SWIG_From_unsigned_SS_char PyInt_FromLong
1634 /*@@*/
1635
1636
1637 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1638 #define SWIG_From_long PyInt_FromLong
1639 /*@@*/
1640
1641 static PyObject *wxColour_Get(wxColour *self){
1642 PyObject* rv = PyTuple_New(3);
1643 int red = -1;
1644 int green = -1;
1645 int blue = -1;
1646 if (self->Ok()) {
1647 red = self->Red();
1648 green = self->Green();
1649 blue = self->Blue();
1650 }
1651 PyTuple_SetItem(rv, 0, PyInt_FromLong(red));
1652 PyTuple_SetItem(rv, 1, PyInt_FromLong(green));
1653 PyTuple_SetItem(rv, 2, PyInt_FromLong(blue));
1654 return rv;
1655 }
1656 static unsigned long wxColour_GetRGB(wxColour *self){
1657 return self->Red() | (self->Green() << 8) | (self->Blue() << 16);
1658 }
1659
1660 SWIGINTERNSHORT PyObject*
1661 SWIG_From_unsigned_SS_long(unsigned long value)
1662 {
1663 return (value > LONG_MAX) ?
1664 PyLong_FromUnsignedLong(value)
1665 : PyInt_FromLong((long)(value));
1666 }
1667
1668
1669 SWIGINTERNSHORT int
1670 SWIG_As_int(PyObject* obj)
1671 {
1672 int v;
1673 if (!SWIG_AsVal_int(obj, &v)) {
1674 /*
1675 this is needed to make valgrind/purify happier.
1676 */
1677 memset((void*)&v, 0, sizeof(int));
1678 }
1679 return v;
1680 }
1681
1682
1683 SWIGINTERNSHORT int
1684 SWIG_Check_int(PyObject* obj)
1685 {
1686 return SWIG_AsVal_int(obj, (int*)0);
1687 }
1688
1689
1690 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1691 #define SWIG_From_int PyInt_FromLong
1692 /*@@*/
1693
1694
1695 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1696 PyObject* o2;
1697 PyObject* o3;
1698
1699 if (!target) {
1700 target = o;
1701 } else if (target == Py_None) {
1702 Py_DECREF(Py_None);
1703 target = o;
1704 } else {
1705 if (!PyTuple_Check(target)) {
1706 o2 = target;
1707 target = PyTuple_New(1);
1708 PyTuple_SetItem(target, 0, o2);
1709 }
1710 o3 = PyTuple_New(1);
1711 PyTuple_SetItem(o3, 0, o);
1712
1713 o2 = target;
1714 target = PySequence_Concat(o2, o3);
1715 Py_DECREF(o2);
1716 Py_DECREF(o3);
1717 }
1718 return target;
1719 }
1720
1721
1722 static PyObject *wxPen_GetDashes(wxPen *self){
1723 wxDash* dashes;
1724 int count = self->GetDashes(&dashes);
1725 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1726 PyObject* retval = PyList_New(0);
1727 for (int x=0; x<count; x++) {
1728 PyObject* pyint = PyInt_FromLong(dashes[x]);
1729 PyList_Append(retval, pyint);
1730 Py_DECREF(pyint);
1731 }
1732 wxPyEndBlockThreads(blocked);
1733 return retval;
1734 }
1735 static void wxPen__SetDashes(wxPen *self,PyObject *_self,PyObject *pyDashes){
1736 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1737 int size = PyList_Size(pyDashes);
1738 wxDash* dashes = (wxDash*)byte_LIST_helper(pyDashes);
1739
1740 // black magic warning! The array of wxDashes needs to exist as
1741 // long as the pen does because wxPen does not copy the array. So
1742 // stick a copy in a Python string object and attach it to _self,
1743 // and then call SetDashes with a pointer to that array. Then
1744 // when the Python pen object is destroyed the array will be
1745 // cleaned up too.
1746 PyObject* strDashes = PyString_FromStringAndSize((char*)dashes, size*sizeof(wxDash));
1747 PyObject_SetAttrString(_self, "_dashes", strDashes);
1748
1749 self->SetDashes(size, (wxDash*)PyString_AS_STRING(strDashes));
1750 delete [] dashes;
1751 Py_DECREF(strDashes);
1752 wxPyEndBlockThreads(blocked);
1753 }
1754 static bool wxPen___eq__(wxPen *self,wxPen const *other){ return other ? (*self == *other) : false; }
1755 static bool wxPen___ne__(wxPen *self,wxPen const *other){ return other ? (*self != *other) : true; }
1756
1757 #include <wx/image.h>
1758
1759 static char** ConvertListOfStrings(PyObject* listOfStrings) {
1760 char** cArray = NULL;
1761 int count;
1762
1763 if (!PyList_Check(listOfStrings)) {
1764 PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
1765 return NULL;
1766 }
1767 count = PyList_Size(listOfStrings);
1768 cArray = new char*[count];
1769
1770 for(int x=0; x<count; x++) {
1771 // TODO: Need some validation and error checking here
1772 cArray[x] = PyString_AsString(PyList_GET_ITEM(listOfStrings, x));
1773 }
1774 return cArray;
1775 }
1776
1777
1778 static wxBitmap *new_wxBitmap(PyObject *listOfStrings){
1779 char** cArray = NULL;
1780 wxBitmap* bmp;
1781
1782 cArray = ConvertListOfStrings(listOfStrings);
1783 if (! cArray)
1784 return NULL;
1785 bmp = new wxBitmap(cArray);
1786 delete [] cArray;
1787 return bmp;
1788 }
1789 static wxBitmap *new_wxBitmap(PyObject *bits,int width,int height,int depth=1){
1790 char* buf;
1791 int length;
1792 PyString_AsStringAndSize(bits, &buf, &length);
1793 return new wxBitmap(buf, width, height, depth);
1794 }
1795
1796 SWIGINTERNSHORT long
1797 SWIG_As_long(PyObject* obj)
1798 {
1799 long v;
1800 if (!SWIG_AsVal_long(obj, &v)) {
1801 /*
1802 this is needed to make valgrind/purify happier.
1803 */
1804 memset((void*)&v, 0, sizeof(long));
1805 }
1806 return v;
1807 }
1808
1809
1810 SWIGINTERNSHORT int
1811 SWIG_Check_long(PyObject* obj)
1812 {
1813 return SWIG_AsVal_long(obj, (long*)0);
1814 }
1815
1816 static void wxBitmap_SetHandle(wxBitmap *self,long handle){ self->SetHandle((WXHANDLE)handle); }
1817 static wxSize wxBitmap_GetSize(wxBitmap *self){
1818 wxSize size(self->GetWidth(), self->GetHeight());
1819 return size;
1820 }
1821 static void wxBitmap_SetMaskColour(wxBitmap *self,wxColour const &colour){
1822 wxMask *mask = new wxMask(*self, colour);
1823 self->SetMask(mask);
1824 }
1825 static void wxBitmap_SetSize(wxBitmap *self,wxSize const &size){
1826 self->SetWidth(size.x);
1827 self->SetHeight(size.y);
1828 }
1829 static bool wxBitmap___eq__(wxBitmap *self,wxBitmap const *other){ return other ? (*self == *other) : false; }
1830 static bool wxBitmap___ne__(wxBitmap *self,wxBitmap const *other){ return other ? (*self != *other) : true; }
1831 static wxMask *new_wxMask(wxBitmap const &bitmap,wxColour const &colour=wxNullColour){
1832 if ( !colour.Ok() )
1833 return new wxMask(bitmap, *wxBLACK);
1834 else
1835 return new wxMask(bitmap, colour);
1836 }
1837
1838 #include <wx/iconbndl.h>
1839
1840 static wxIcon *new_wxIcon(wxBitmap const &bmp){
1841 wxIcon* icon = new wxIcon();
1842 icon->CopyFromBitmap(bmp);
1843 return icon;
1844 }
1845 static wxIcon *new_wxIcon(PyObject *listOfStrings){
1846 char** cArray = NULL;
1847 wxIcon* icon;
1848
1849 cArray = ConvertListOfStrings(listOfStrings);
1850 if (! cArray)
1851 return NULL;
1852 icon = new wxIcon(cArray);
1853 delete [] cArray;
1854 return icon;
1855 }
1856 static void wxIcon_SetHandle(wxIcon *self,long handle){ self->SetHandle((WXHANDLE)handle); }
1857 static wxIconLocation *new_wxIconLocation(wxString const *filename=&wxPyEmptyString,int num=0){
1858
1859 return new wxIconLocation(*filename, num);
1860
1861
1862
1863 }
1864 static void wxIconLocation_SetIndex(wxIconLocation *self,int num){
1865
1866 self->SetIndex(num);
1867
1868
1869
1870 }
1871 static int wxIconLocation_GetIndex(wxIconLocation *self){
1872
1873 return self->GetIndex();
1874
1875
1876
1877 }
1878 static wxCursor *new_wxCursor(wxString const &cursorName,long type,int hotSpotX=0,int hotSpotY=0){
1879 #ifdef __WXGTK__
1880 wxImage img(cursorName, type);
1881 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, hotSpotX);
1882 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, hotSpotY);
1883 return new wxCursor(img);
1884 #else
1885 return new wxCursor(cursorName, type, hotSpotX, hotSpotY);
1886 #endif
1887 }
1888 static void wxCursor_SetHandle(wxCursor *self,long handle){ self->SetHandle((WXHANDLE)handle); }
1889
1890
1891 static void wxRegionIterator_Next(wxRegionIterator *self){
1892 (*self) ++;
1893 }
1894 static bool wxRegionIterator___nonzero__(wxRegionIterator *self){
1895 return self->operator bool();
1896 }
1897
1898 #include <wx/fontutil.h>
1899 #include <wx/fontmap.h>
1900 #include <wx/fontenum.h>
1901
1902 static wxString wxNativeFontInfo___str__(wxNativeFontInfo *self){
1903 return self->ToString();
1904 }
1905
1906 wxNativeEncodingInfo* wxGetNativeFontEncoding(wxFontEncoding encoding)
1907 { wxPyRaiseNotImplemented(); return NULL; }
1908
1909 bool wxTestFontEncoding(const wxNativeEncodingInfo& info)
1910 { wxPyRaiseNotImplemented(); return false; }
1911
1912 static PyObject *wxFontMapper_GetAltForEncoding(wxFontMapper *self,wxFontEncoding encoding,wxString const &facename=wxPyEmptyString,bool interactive=true){
1913 wxFontEncoding alt_enc;
1914 if (self->GetAltForEncoding(encoding, &alt_enc, facename, interactive))
1915 return PyInt_FromLong(alt_enc);
1916 else {
1917 Py_INCREF(Py_None);
1918 return Py_None;
1919 }
1920 }
1921 static wxFont *new_wxFont(wxString const &info){
1922 wxNativeFontInfo nfi;
1923 nfi.FromString(info);
1924 return new wxFont(nfi);
1925 }
1926 static wxFont *new_wxFont(int pointSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxPyEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1927 return wxFont::New(pointSize, family, flags, face, encoding);
1928 }
1929 static wxFont *new_wxFont(wxSize const &pixelSize,int family,int style,int weight,bool underlined=false,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1930 return wxFontBase::New(pixelSize, family,
1931 style, weight, underlined,
1932 face, encoding);
1933 }
1934 static bool wxFont___eq__(wxFont *self,wxFont const *other){ return other ? (*self == *other) : false; }
1935 static bool wxFont___ne__(wxFont *self,wxFont const *other){ return other ? (*self != *other) : true; }
1936
1937 class wxPyFontEnumerator : public wxFontEnumerator {
1938 public:
1939 wxPyFontEnumerator() {}
1940 ~wxPyFontEnumerator() {}
1941
1942 DEC_PYCALLBACK_BOOL_STRING(OnFacename);
1943 DEC_PYCALLBACK_BOOL_STRINGSTRING(OnFontEncoding);
1944
1945 PYPRIVATE;
1946 };
1947
1948 IMP_PYCALLBACK_BOOL_STRING(wxPyFontEnumerator, wxFontEnumerator, OnFacename);
1949 IMP_PYCALLBACK_BOOL_STRINGSTRING(wxPyFontEnumerator, wxFontEnumerator, OnFontEncoding);
1950
1951
1952 static PyObject *wxPyFontEnumerator_GetEncodings(wxPyFontEnumerator *self){
1953 wxArrayString* arr = self->GetEncodings();
1954 if (arr)
1955 return wxArrayString2PyList_helper(*arr);
1956 else
1957 return PyList_New(0);
1958 }
1959 static PyObject *wxPyFontEnumerator_GetFacenames(wxPyFontEnumerator *self){
1960 wxArrayString* arr = self->GetFacenames();
1961 if (arr)
1962 return wxArrayString2PyList_helper(*arr);
1963 else
1964 return PyList_New(0);
1965 }
1966
1967 #include <locale.h>
1968
1969 static wxLocale *new_wxLocale(int language=-1,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
1970 wxLocale* loc;
1971 if (language == -1)
1972 loc = new wxLocale();
1973 else
1974 loc = new wxLocale(language, flags);
1975 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1976 // for the floating point conversions and such to work right.
1977 #if PY_VERSION_HEX < 0x02040000
1978 setlocale(LC_NUMERIC, "C");
1979 #endif
1980 return loc;
1981 }
1982 static bool wxLocale_Init1(wxLocale *self,wxString const &szName,wxString const &szShort=wxPyEmptyString,wxString const &szLocale=wxPyEmptyString,bool bLoadDefault=true,bool bConvertEncoding=false){
1983 bool rc = self->Init(szName, szShort, szLocale, bLoadDefault, bConvertEncoding);
1984 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1985 // for the floating point conversions and such to work right.
1986 #if PY_VERSION_HEX < 0x02040000
1987 setlocale(LC_NUMERIC, "C");
1988 #endif
1989 return rc;
1990 }
1991 static bool wxLocale_Init2(wxLocale *self,int language=wxLANGUAGE_DEFAULT,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
1992 bool rc = self->Init(language, flags);
1993 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1994 // for the floating point conversions and such to work right.
1995 #if PY_VERSION_HEX < 0x02040000
1996 setlocale(LC_NUMERIC, "C");
1997 #endif
1998 return rc;
1999 }
2000
2001 #include "wx/wxPython/pydrawxxx.h"
2002
2003 static wxColour wxDC_GetPixel(wxDC *self,int x,int y){
2004 wxColour col;
2005 self->GetPixel(x, y, &col);
2006 return col;
2007 }
2008 static wxColour wxDC_GetPixelPoint(wxDC *self,wxPoint const &pt){
2009 wxColour col;
2010 self->GetPixel(pt, &col);
2011 return col;
2012 }
2013
2014 SWIGINTERN int
2015 SWIG_AsVal_double(PyObject *obj, double* val)
2016 {
2017 if (PyNumber_Check(obj)) {
2018 if (val) *val = PyFloat_AsDouble(obj);
2019 return 1;
2020 }
2021 else {
2022 SWIG_type_error("number", obj);
2023 }
2024 return 0;
2025 }
2026
2027
2028 SWIGINTERNSHORT double
2029 SWIG_As_double(PyObject* obj)
2030 {
2031 double v;
2032 if (!SWIG_AsVal_double(obj, &v)) {
2033 /*
2034 this is needed to make valgrind/purify happier.
2035 */
2036 memset((void*)&v, 0, sizeof(double));
2037 }
2038 return v;
2039 }
2040
2041
2042 SWIGINTERNSHORT int
2043 SWIG_Check_double(PyObject* obj)
2044 {
2045 return SWIG_AsVal_double(obj, (double*)0);
2046 }
2047
2048 static wxRect wxDC_DrawImageLabel(wxDC *self,wxString const &text,wxBitmap const &image,wxRect const &rect,int alignment=wxALIGN_LEFT|wxALIGN_TOP,int indexAccel=-1){
2049 wxRect rv;
2050 self->DrawLabel(text, image, rect, alignment, indexAccel, &rv);
2051 return rv;
2052 }
2053
2054 static wxRect wxDC_GetClippingRect(wxDC *self){
2055 wxRect rect;
2056 self->GetClippingBox(rect);
2057 return rect;
2058 }
2059 static wxArrayInt wxDC_GetPartialTextExtents(wxDC *self,wxString const &text){
2060 wxArrayInt widths;
2061 self->GetPartialTextExtents(text, widths);
2062 return widths;
2063 }
2064
2065 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2066 #define SWIG_From_double PyFloat_FromDouble
2067 /*@@*/
2068
2069
2070 static void wxDC_SetLogicalOriginPoint(wxDC *self,wxPoint const &point){
2071 self->SetLogicalOrigin(point.x, point.y);
2072 }
2073 static void wxDC_SetDeviceOriginPoint(wxDC *self,wxPoint const &point){
2074 self->SetDeviceOrigin(point.x, point.y);
2075 }
2076 static void wxDC_CalcBoundingBoxPoint(wxDC *self,wxPoint const &point){
2077 self->CalcBoundingBox(point.x, point.y);
2078 }
2079 static PyObject *wxDC__DrawPointList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2080 return wxPyDrawXXXList(*self, wxPyDrawXXXPoint, pyCoords, pyPens, pyBrushes);
2081 }
2082 static PyObject *wxDC__DrawLineList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2083 return wxPyDrawXXXList(*self, wxPyDrawXXXLine, pyCoords, pyPens, pyBrushes);
2084 }
2085 static PyObject *wxDC__DrawRectangleList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2086 return wxPyDrawXXXList(*self, wxPyDrawXXXRectangle, pyCoords, pyPens, pyBrushes);
2087 }
2088 static PyObject *wxDC__DrawEllipseList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2089 return wxPyDrawXXXList(*self, wxPyDrawXXXEllipse, pyCoords, pyPens, pyBrushes);
2090 }
2091 static PyObject *wxDC__DrawPolygonList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2092 return wxPyDrawXXXList(*self, wxPyDrawXXXPolygon, pyCoords, pyPens, pyBrushes);
2093 }
2094 static PyObject *wxDC__DrawTextList(wxDC *self,PyObject *textList,PyObject *pyPoints,PyObject *foregroundList,PyObject *backgroundList){
2095 return wxPyDrawTextList(*self, textList, pyPoints, foregroundList, backgroundList);
2096 }
2097
2098 static void wxDC_GetBoundingBox(wxDC* dc, int* x1, int* y1, int* x2, int* y2) {
2099 *x1 = dc->MinX();
2100 *y1 = dc->MinY();
2101 *x2 = dc->MaxX();
2102 *y2 = dc->MaxY();
2103 }
2104
2105
2106 #include <wx/dcbuffer.h>
2107
2108
2109 #include <wx/dcps.h>
2110
2111
2112 #include <wx/metafile.h>
2113
2114
2115
2116 static void wxColourDatabase_Append(wxColourDatabase *self,wxString const &name,int red,int green,int blue){
2117 self->AddColour(name, wxColour(red, green, blue));
2118 }
2119
2120 #include <wx/effects.h>
2121
2122 #ifdef __cplusplus
2123 extern "C" {
2124 #endif
2125 static PyObject *_wrap_new_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2126 PyObject *resultobj;
2127 wxGDIObject *result;
2128 char *kwnames[] = {
2129 NULL
2130 };
2131
2132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GDIObject",kwnames)) goto fail;
2133 {
2134 if (!wxPyCheckForApp()) SWIG_fail;
2135 PyThreadState* __tstate = wxPyBeginAllowThreads();
2136 result = (wxGDIObject *)new wxGDIObject();
2137
2138 wxPyEndAllowThreads(__tstate);
2139 if (PyErr_Occurred()) SWIG_fail;
2140 }
2141 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGDIObject, 1);
2142 return resultobj;
2143 fail:
2144 return NULL;
2145 }
2146
2147
2148 static PyObject *_wrap_delete_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2149 PyObject *resultobj;
2150 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2151 PyObject * obj0 = 0 ;
2152 char *kwnames[] = {
2153 (char *) "self", NULL
2154 };
2155
2156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GDIObject",kwnames,&obj0)) goto fail;
2157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2158 if (SWIG_arg_fail(1)) SWIG_fail;
2159 {
2160 PyThreadState* __tstate = wxPyBeginAllowThreads();
2161 delete arg1;
2162
2163 wxPyEndAllowThreads(__tstate);
2164 if (PyErr_Occurred()) SWIG_fail;
2165 }
2166 Py_INCREF(Py_None); resultobj = Py_None;
2167 return resultobj;
2168 fail:
2169 return NULL;
2170 }
2171
2172
2173 static PyObject *_wrap_GDIObject_GetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2174 PyObject *resultobj;
2175 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2176 bool result;
2177 PyObject * obj0 = 0 ;
2178 char *kwnames[] = {
2179 (char *) "self", NULL
2180 };
2181
2182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_GetVisible",kwnames,&obj0)) goto fail;
2183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2184 if (SWIG_arg_fail(1)) SWIG_fail;
2185 {
2186 PyThreadState* __tstate = wxPyBeginAllowThreads();
2187 result = (bool)(arg1)->GetVisible();
2188
2189 wxPyEndAllowThreads(__tstate);
2190 if (PyErr_Occurred()) SWIG_fail;
2191 }
2192 {
2193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2194 }
2195 return resultobj;
2196 fail:
2197 return NULL;
2198 }
2199
2200
2201 static PyObject *_wrap_GDIObject_SetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2202 PyObject *resultobj;
2203 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2204 bool arg2 ;
2205 PyObject * obj0 = 0 ;
2206 PyObject * obj1 = 0 ;
2207 char *kwnames[] = {
2208 (char *) "self",(char *) "visible", NULL
2209 };
2210
2211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GDIObject_SetVisible",kwnames,&obj0,&obj1)) goto fail;
2212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2213 if (SWIG_arg_fail(1)) SWIG_fail;
2214 {
2215 arg2 = (bool)(SWIG_As_bool(obj1));
2216 if (SWIG_arg_fail(2)) SWIG_fail;
2217 }
2218 {
2219 PyThreadState* __tstate = wxPyBeginAllowThreads();
2220 (arg1)->SetVisible(arg2);
2221
2222 wxPyEndAllowThreads(__tstate);
2223 if (PyErr_Occurred()) SWIG_fail;
2224 }
2225 Py_INCREF(Py_None); resultobj = Py_None;
2226 return resultobj;
2227 fail:
2228 return NULL;
2229 }
2230
2231
2232 static PyObject *_wrap_GDIObject_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
2233 PyObject *resultobj;
2234 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2235 bool result;
2236 PyObject * obj0 = 0 ;
2237 char *kwnames[] = {
2238 (char *) "self", NULL
2239 };
2240
2241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_IsNull",kwnames,&obj0)) goto fail;
2242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2243 if (SWIG_arg_fail(1)) SWIG_fail;
2244 {
2245 PyThreadState* __tstate = wxPyBeginAllowThreads();
2246 result = (bool)(arg1)->IsNull();
2247
2248 wxPyEndAllowThreads(__tstate);
2249 if (PyErr_Occurred()) SWIG_fail;
2250 }
2251 {
2252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2253 }
2254 return resultobj;
2255 fail:
2256 return NULL;
2257 }
2258
2259
2260 static PyObject * GDIObject_swigregister(PyObject *, PyObject *args) {
2261 PyObject *obj;
2262 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2263 SWIG_TypeClientData(SWIGTYPE_p_wxGDIObject, obj);
2264 Py_INCREF(obj);
2265 return Py_BuildValue((char *)"");
2266 }
2267 static PyObject *_wrap_new_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2268 PyObject *resultobj;
2269 byte arg1 = (byte) 0 ;
2270 byte arg2 = (byte) 0 ;
2271 byte arg3 = (byte) 0 ;
2272 wxColour *result;
2273 PyObject * obj0 = 0 ;
2274 PyObject * obj1 = 0 ;
2275 PyObject * obj2 = 0 ;
2276 char *kwnames[] = {
2277 (char *) "red",(char *) "green",(char *) "blue", NULL
2278 };
2279
2280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Colour",kwnames,&obj0,&obj1,&obj2)) goto fail;
2281 if (obj0) {
2282 {
2283 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
2284 if (SWIG_arg_fail(1)) SWIG_fail;
2285 }
2286 }
2287 if (obj1) {
2288 {
2289 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2290 if (SWIG_arg_fail(2)) SWIG_fail;
2291 }
2292 }
2293 if (obj2) {
2294 {
2295 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2296 if (SWIG_arg_fail(3)) SWIG_fail;
2297 }
2298 }
2299 {
2300 PyThreadState* __tstate = wxPyBeginAllowThreads();
2301 result = (wxColour *)new wxColour(arg1,arg2,arg3);
2302
2303 wxPyEndAllowThreads(__tstate);
2304 if (PyErr_Occurred()) SWIG_fail;
2305 }
2306 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2307 return resultobj;
2308 fail:
2309 return NULL;
2310 }
2311
2312
2313 static PyObject *_wrap_new_NamedColour(PyObject *, PyObject *args, PyObject *kwargs) {
2314 PyObject *resultobj;
2315 wxString *arg1 = 0 ;
2316 wxColour *result;
2317 bool temp1 = false ;
2318 PyObject * obj0 = 0 ;
2319 char *kwnames[] = {
2320 (char *) "colorName", NULL
2321 };
2322
2323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_NamedColour",kwnames,&obj0)) goto fail;
2324 {
2325 arg1 = wxString_in_helper(obj0);
2326 if (arg1 == NULL) SWIG_fail;
2327 temp1 = true;
2328 }
2329 {
2330 if (!wxPyCheckForApp()) SWIG_fail;
2331 PyThreadState* __tstate = wxPyBeginAllowThreads();
2332 result = (wxColour *)new wxColour((wxString const &)*arg1);
2333
2334 wxPyEndAllowThreads(__tstate);
2335 if (PyErr_Occurred()) SWIG_fail;
2336 }
2337 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2338 {
2339 if (temp1)
2340 delete arg1;
2341 }
2342 return resultobj;
2343 fail:
2344 {
2345 if (temp1)
2346 delete arg1;
2347 }
2348 return NULL;
2349 }
2350
2351
2352 static PyObject *_wrap_new_ColourRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2353 PyObject *resultobj;
2354 unsigned long arg1 ;
2355 wxColour *result;
2356 PyObject * obj0 = 0 ;
2357 char *kwnames[] = {
2358 (char *) "colRGB", NULL
2359 };
2360
2361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ColourRGB",kwnames,&obj0)) goto fail;
2362 {
2363 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
2364 if (SWIG_arg_fail(1)) SWIG_fail;
2365 }
2366 {
2367 PyThreadState* __tstate = wxPyBeginAllowThreads();
2368 result = (wxColour *)new wxColour(arg1);
2369
2370 wxPyEndAllowThreads(__tstate);
2371 if (PyErr_Occurred()) SWIG_fail;
2372 }
2373 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2374 return resultobj;
2375 fail:
2376 return NULL;
2377 }
2378
2379
2380 static PyObject *_wrap_delete_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2381 PyObject *resultobj;
2382 wxColour *arg1 = (wxColour *) 0 ;
2383 PyObject * obj0 = 0 ;
2384 char *kwnames[] = {
2385 (char *) "self", NULL
2386 };
2387
2388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Colour",kwnames,&obj0)) goto fail;
2389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2390 if (SWIG_arg_fail(1)) SWIG_fail;
2391 {
2392 PyThreadState* __tstate = wxPyBeginAllowThreads();
2393 delete arg1;
2394
2395 wxPyEndAllowThreads(__tstate);
2396 if (PyErr_Occurred()) SWIG_fail;
2397 }
2398 Py_INCREF(Py_None); resultobj = Py_None;
2399 return resultobj;
2400 fail:
2401 return NULL;
2402 }
2403
2404
2405 static PyObject *_wrap_Colour_Red(PyObject *, PyObject *args, PyObject *kwargs) {
2406 PyObject *resultobj;
2407 wxColour *arg1 = (wxColour *) 0 ;
2408 byte result;
2409 PyObject * obj0 = 0 ;
2410 char *kwnames[] = {
2411 (char *) "self", NULL
2412 };
2413
2414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Red",kwnames,&obj0)) goto fail;
2415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2416 if (SWIG_arg_fail(1)) SWIG_fail;
2417 {
2418 PyThreadState* __tstate = wxPyBeginAllowThreads();
2419 result = (byte)(arg1)->Red();
2420
2421 wxPyEndAllowThreads(__tstate);
2422 if (PyErr_Occurred()) SWIG_fail;
2423 }
2424 {
2425 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2426 }
2427 return resultobj;
2428 fail:
2429 return NULL;
2430 }
2431
2432
2433 static PyObject *_wrap_Colour_Green(PyObject *, PyObject *args, PyObject *kwargs) {
2434 PyObject *resultobj;
2435 wxColour *arg1 = (wxColour *) 0 ;
2436 byte result;
2437 PyObject * obj0 = 0 ;
2438 char *kwnames[] = {
2439 (char *) "self", NULL
2440 };
2441
2442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Green",kwnames,&obj0)) goto fail;
2443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2444 if (SWIG_arg_fail(1)) SWIG_fail;
2445 {
2446 PyThreadState* __tstate = wxPyBeginAllowThreads();
2447 result = (byte)(arg1)->Green();
2448
2449 wxPyEndAllowThreads(__tstate);
2450 if (PyErr_Occurred()) SWIG_fail;
2451 }
2452 {
2453 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2454 }
2455 return resultobj;
2456 fail:
2457 return NULL;
2458 }
2459
2460
2461 static PyObject *_wrap_Colour_Blue(PyObject *, PyObject *args, PyObject *kwargs) {
2462 PyObject *resultobj;
2463 wxColour *arg1 = (wxColour *) 0 ;
2464 byte result;
2465 PyObject * obj0 = 0 ;
2466 char *kwnames[] = {
2467 (char *) "self", NULL
2468 };
2469
2470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Blue",kwnames,&obj0)) goto fail;
2471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2472 if (SWIG_arg_fail(1)) SWIG_fail;
2473 {
2474 PyThreadState* __tstate = wxPyBeginAllowThreads();
2475 result = (byte)(arg1)->Blue();
2476
2477 wxPyEndAllowThreads(__tstate);
2478 if (PyErr_Occurred()) SWIG_fail;
2479 }
2480 {
2481 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2482 }
2483 return resultobj;
2484 fail:
2485 return NULL;
2486 }
2487
2488
2489 static PyObject *_wrap_Colour_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
2490 PyObject *resultobj;
2491 wxColour *arg1 = (wxColour *) 0 ;
2492 bool result;
2493 PyObject * obj0 = 0 ;
2494 char *kwnames[] = {
2495 (char *) "self", NULL
2496 };
2497
2498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Ok",kwnames,&obj0)) goto fail;
2499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2500 if (SWIG_arg_fail(1)) SWIG_fail;
2501 {
2502 PyThreadState* __tstate = wxPyBeginAllowThreads();
2503 result = (bool)(arg1)->Ok();
2504
2505 wxPyEndAllowThreads(__tstate);
2506 if (PyErr_Occurred()) SWIG_fail;
2507 }
2508 {
2509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2510 }
2511 return resultobj;
2512 fail:
2513 return NULL;
2514 }
2515
2516
2517 static PyObject *_wrap_Colour_Set(PyObject *, PyObject *args, PyObject *kwargs) {
2518 PyObject *resultobj;
2519 wxColour *arg1 = (wxColour *) 0 ;
2520 byte arg2 ;
2521 byte arg3 ;
2522 byte arg4 ;
2523 PyObject * obj0 = 0 ;
2524 PyObject * obj1 = 0 ;
2525 PyObject * obj2 = 0 ;
2526 PyObject * obj3 = 0 ;
2527 char *kwnames[] = {
2528 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2529 };
2530
2531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Colour_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2533 if (SWIG_arg_fail(1)) SWIG_fail;
2534 {
2535 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2536 if (SWIG_arg_fail(2)) SWIG_fail;
2537 }
2538 {
2539 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2540 if (SWIG_arg_fail(3)) SWIG_fail;
2541 }
2542 {
2543 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2544 if (SWIG_arg_fail(4)) SWIG_fail;
2545 }
2546 {
2547 PyThreadState* __tstate = wxPyBeginAllowThreads();
2548 (arg1)->Set(arg2,arg3,arg4);
2549
2550 wxPyEndAllowThreads(__tstate);
2551 if (PyErr_Occurred()) SWIG_fail;
2552 }
2553 Py_INCREF(Py_None); resultobj = Py_None;
2554 return resultobj;
2555 fail:
2556 return NULL;
2557 }
2558
2559
2560 static PyObject *_wrap_Colour_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2561 PyObject *resultobj;
2562 wxColour *arg1 = (wxColour *) 0 ;
2563 unsigned long arg2 ;
2564 PyObject * obj0 = 0 ;
2565 PyObject * obj1 = 0 ;
2566 char *kwnames[] = {
2567 (char *) "self",(char *) "colRGB", NULL
2568 };
2569
2570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetRGB",kwnames,&obj0,&obj1)) goto fail;
2571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2572 if (SWIG_arg_fail(1)) SWIG_fail;
2573 {
2574 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
2575 if (SWIG_arg_fail(2)) SWIG_fail;
2576 }
2577 {
2578 PyThreadState* __tstate = wxPyBeginAllowThreads();
2579 (arg1)->Set(arg2);
2580
2581 wxPyEndAllowThreads(__tstate);
2582 if (PyErr_Occurred()) SWIG_fail;
2583 }
2584 Py_INCREF(Py_None); resultobj = Py_None;
2585 return resultobj;
2586 fail:
2587 return NULL;
2588 }
2589
2590
2591 static PyObject *_wrap_Colour_SetFromName(PyObject *, PyObject *args, PyObject *kwargs) {
2592 PyObject *resultobj;
2593 wxColour *arg1 = (wxColour *) 0 ;
2594 wxString *arg2 = 0 ;
2595 bool temp2 = false ;
2596 PyObject * obj0 = 0 ;
2597 PyObject * obj1 = 0 ;
2598 char *kwnames[] = {
2599 (char *) "self",(char *) "colourName", NULL
2600 };
2601
2602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetFromName",kwnames,&obj0,&obj1)) goto fail;
2603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2604 if (SWIG_arg_fail(1)) SWIG_fail;
2605 {
2606 arg2 = wxString_in_helper(obj1);
2607 if (arg2 == NULL) SWIG_fail;
2608 temp2 = true;
2609 }
2610 {
2611 PyThreadState* __tstate = wxPyBeginAllowThreads();
2612 (arg1)->InitFromName((wxString const &)*arg2);
2613
2614 wxPyEndAllowThreads(__tstate);
2615 if (PyErr_Occurred()) SWIG_fail;
2616 }
2617 Py_INCREF(Py_None); resultobj = Py_None;
2618 {
2619 if (temp2)
2620 delete arg2;
2621 }
2622 return resultobj;
2623 fail:
2624 {
2625 if (temp2)
2626 delete arg2;
2627 }
2628 return NULL;
2629 }
2630
2631
2632 static PyObject *_wrap_Colour_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2633 PyObject *resultobj;
2634 wxColour *arg1 = (wxColour *) 0 ;
2635 long result;
2636 PyObject * obj0 = 0 ;
2637 char *kwnames[] = {
2638 (char *) "self", NULL
2639 };
2640
2641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetPixel",kwnames,&obj0)) goto fail;
2642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2643 if (SWIG_arg_fail(1)) SWIG_fail;
2644 {
2645 PyThreadState* __tstate = wxPyBeginAllowThreads();
2646 result = (long)((wxColour const *)arg1)->GetPixel();
2647
2648 wxPyEndAllowThreads(__tstate);
2649 if (PyErr_Occurred()) SWIG_fail;
2650 }
2651 {
2652 resultobj = SWIG_From_long((long)(result));
2653 }
2654 return resultobj;
2655 fail:
2656 return NULL;
2657 }
2658
2659
2660 static PyObject *_wrap_Colour___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
2661 PyObject *resultobj;
2662 wxColour *arg1 = (wxColour *) 0 ;
2663 wxColour *arg2 = 0 ;
2664 bool result;
2665 wxColour temp2 ;
2666 PyObject * obj0 = 0 ;
2667 PyObject * obj1 = 0 ;
2668 char *kwnames[] = {
2669 (char *) "self",(char *) "colour", NULL
2670 };
2671
2672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___eq__",kwnames,&obj0,&obj1)) goto fail;
2673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2674 if (SWIG_arg_fail(1)) SWIG_fail;
2675 {
2676 arg2 = &temp2;
2677 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2678 }
2679 {
2680 PyThreadState* __tstate = wxPyBeginAllowThreads();
2681 result = (bool)((wxColour const *)arg1)->operator ==((wxColour const &)*arg2);
2682
2683 wxPyEndAllowThreads(__tstate);
2684 if (PyErr_Occurred()) SWIG_fail;
2685 }
2686 {
2687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2688 }
2689 return resultobj;
2690 fail:
2691 return NULL;
2692 }
2693
2694
2695 static PyObject *_wrap_Colour___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
2696 PyObject *resultobj;
2697 wxColour *arg1 = (wxColour *) 0 ;
2698 wxColour *arg2 = 0 ;
2699 bool result;
2700 wxColour temp2 ;
2701 PyObject * obj0 = 0 ;
2702 PyObject * obj1 = 0 ;
2703 char *kwnames[] = {
2704 (char *) "self",(char *) "colour", NULL
2705 };
2706
2707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___ne__",kwnames,&obj0,&obj1)) goto fail;
2708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2709 if (SWIG_arg_fail(1)) SWIG_fail;
2710 {
2711 arg2 = &temp2;
2712 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2713 }
2714 {
2715 PyThreadState* __tstate = wxPyBeginAllowThreads();
2716 result = (bool)((wxColour const *)arg1)->operator !=((wxColour const &)*arg2);
2717
2718 wxPyEndAllowThreads(__tstate);
2719 if (PyErr_Occurred()) SWIG_fail;
2720 }
2721 {
2722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2723 }
2724 return resultobj;
2725 fail:
2726 return NULL;
2727 }
2728
2729
2730 static PyObject *_wrap_Colour_Get(PyObject *, PyObject *args, PyObject *kwargs) {
2731 PyObject *resultobj;
2732 wxColour *arg1 = (wxColour *) 0 ;
2733 PyObject *result;
2734 PyObject * obj0 = 0 ;
2735 char *kwnames[] = {
2736 (char *) "self", NULL
2737 };
2738
2739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Get",kwnames,&obj0)) goto fail;
2740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2741 if (SWIG_arg_fail(1)) SWIG_fail;
2742 {
2743 PyThreadState* __tstate = wxPyBeginAllowThreads();
2744 result = (PyObject *)wxColour_Get(arg1);
2745
2746 wxPyEndAllowThreads(__tstate);
2747 if (PyErr_Occurred()) SWIG_fail;
2748 }
2749 resultobj = result;
2750 return resultobj;
2751 fail:
2752 return NULL;
2753 }
2754
2755
2756 static PyObject *_wrap_Colour_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2757 PyObject *resultobj;
2758 wxColour *arg1 = (wxColour *) 0 ;
2759 unsigned long result;
2760 PyObject * obj0 = 0 ;
2761 char *kwnames[] = {
2762 (char *) "self", NULL
2763 };
2764
2765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetRGB",kwnames,&obj0)) goto fail;
2766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2767 if (SWIG_arg_fail(1)) SWIG_fail;
2768 {
2769 PyThreadState* __tstate = wxPyBeginAllowThreads();
2770 result = (unsigned long)wxColour_GetRGB(arg1);
2771
2772 wxPyEndAllowThreads(__tstate);
2773 if (PyErr_Occurred()) SWIG_fail;
2774 }
2775 {
2776 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
2777 }
2778 return resultobj;
2779 fail:
2780 return NULL;
2781 }
2782
2783
2784 static PyObject * Colour_swigregister(PyObject *, PyObject *args) {
2785 PyObject *obj;
2786 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2787 SWIG_TypeClientData(SWIGTYPE_p_wxColour, obj);
2788 Py_INCREF(obj);
2789 return Py_BuildValue((char *)"");
2790 }
2791 static PyObject *_wrap_new_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2792 PyObject *resultobj;
2793 int arg1 ;
2794 unsigned char *arg2 = (unsigned char *) 0 ;
2795 unsigned char *arg3 = (unsigned char *) 0 ;
2796 unsigned char *arg4 = (unsigned char *) 0 ;
2797 wxPalette *result;
2798 PyObject * obj0 = 0 ;
2799 PyObject * obj1 = 0 ;
2800 PyObject * obj2 = 0 ;
2801 PyObject * obj3 = 0 ;
2802 char *kwnames[] = {
2803 (char *) "n",(char *) "red",(char *) "green",(char *) "blue", NULL
2804 };
2805
2806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_Palette",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2807 {
2808 arg1 = (int)(SWIG_As_int(obj0));
2809 if (SWIG_arg_fail(1)) SWIG_fail;
2810 }
2811 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2812 if (SWIG_arg_fail(2)) SWIG_fail;
2813 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2814 if (SWIG_arg_fail(3)) SWIG_fail;
2815 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2816 if (SWIG_arg_fail(4)) SWIG_fail;
2817 {
2818 if (!wxPyCheckForApp()) SWIG_fail;
2819 PyThreadState* __tstate = wxPyBeginAllowThreads();
2820 result = (wxPalette *)new wxPalette(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
2821
2822 wxPyEndAllowThreads(__tstate);
2823 if (PyErr_Occurred()) SWIG_fail;
2824 }
2825 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 1);
2826 return resultobj;
2827 fail:
2828 return NULL;
2829 }
2830
2831
2832 static PyObject *_wrap_delete_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2833 PyObject *resultobj;
2834 wxPalette *arg1 = (wxPalette *) 0 ;
2835 PyObject * obj0 = 0 ;
2836 char *kwnames[] = {
2837 (char *) "self", NULL
2838 };
2839
2840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Palette",kwnames,&obj0)) goto fail;
2841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2842 if (SWIG_arg_fail(1)) SWIG_fail;
2843 {
2844 PyThreadState* __tstate = wxPyBeginAllowThreads();
2845 delete arg1;
2846
2847 wxPyEndAllowThreads(__tstate);
2848 if (PyErr_Occurred()) SWIG_fail;
2849 }
2850 Py_INCREF(Py_None); resultobj = Py_None;
2851 return resultobj;
2852 fail:
2853 return NULL;
2854 }
2855
2856
2857 static PyObject *_wrap_Palette_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2858 PyObject *resultobj;
2859 wxPalette *arg1 = (wxPalette *) 0 ;
2860 byte arg2 ;
2861 byte arg3 ;
2862 byte arg4 ;
2863 int result;
2864 PyObject * obj0 = 0 ;
2865 PyObject * obj1 = 0 ;
2866 PyObject * obj2 = 0 ;
2867 PyObject * obj3 = 0 ;
2868 char *kwnames[] = {
2869 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2870 };
2871
2872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Palette_GetPixel",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2874 if (SWIG_arg_fail(1)) SWIG_fail;
2875 {
2876 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2877 if (SWIG_arg_fail(2)) SWIG_fail;
2878 }
2879 {
2880 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2881 if (SWIG_arg_fail(3)) SWIG_fail;
2882 }
2883 {
2884 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2885 if (SWIG_arg_fail(4)) SWIG_fail;
2886 }
2887 {
2888 PyThreadState* __tstate = wxPyBeginAllowThreads();
2889 result = (int)(arg1)->GetPixel(arg2,arg3,arg4);
2890
2891 wxPyEndAllowThreads(__tstate);
2892 if (PyErr_Occurred()) SWIG_fail;
2893 }
2894 {
2895 resultobj = SWIG_From_int((int)(result));
2896 }
2897 return resultobj;
2898 fail:
2899 return NULL;
2900 }
2901
2902
2903 static PyObject *_wrap_Palette_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2904 PyObject *resultobj;
2905 wxPalette *arg1 = (wxPalette *) 0 ;
2906 int arg2 ;
2907 byte *arg3 = (byte *) 0 ;
2908 byte *arg4 = (byte *) 0 ;
2909 byte *arg5 = (byte *) 0 ;
2910 bool result;
2911 byte temp3 ;
2912 int res3 = 0 ;
2913 byte temp4 ;
2914 int res4 = 0 ;
2915 byte temp5 ;
2916 int res5 = 0 ;
2917 PyObject * obj0 = 0 ;
2918 PyObject * obj1 = 0 ;
2919 char *kwnames[] = {
2920 (char *) "self",(char *) "pixel", NULL
2921 };
2922
2923 arg3 = &temp3; res3 = SWIG_NEWOBJ;
2924 arg4 = &temp4; res4 = SWIG_NEWOBJ;
2925 arg5 = &temp5; res5 = SWIG_NEWOBJ;
2926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Palette_GetRGB",kwnames,&obj0,&obj1)) goto fail;
2927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2928 if (SWIG_arg_fail(1)) SWIG_fail;
2929 {
2930 arg2 = (int)(SWIG_As_int(obj1));
2931 if (SWIG_arg_fail(2)) SWIG_fail;
2932 }
2933 {
2934 PyThreadState* __tstate = wxPyBeginAllowThreads();
2935 result = (bool)(arg1)->GetRGB(arg2,arg3,arg4,arg5);
2936
2937 wxPyEndAllowThreads(__tstate);
2938 if (PyErr_Occurred()) SWIG_fail;
2939 }
2940 {
2941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2942 }
2943 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
2944 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
2945 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
2946 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
2947 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
2948 SWIG_From_unsigned_SS_char((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_unsigned_char, 0)));
2949 return resultobj;
2950 fail:
2951 return NULL;
2952 }
2953
2954
2955 static PyObject *_wrap_Palette_GetColoursCount(PyObject *, PyObject *args, PyObject *kwargs) {
2956 PyObject *resultobj;
2957 wxPalette *arg1 = (wxPalette *) 0 ;
2958 int result;
2959 PyObject * obj0 = 0 ;
2960 char *kwnames[] = {
2961 (char *) "self", NULL
2962 };
2963
2964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_GetColoursCount",kwnames,&obj0)) goto fail;
2965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2966 if (SWIG_arg_fail(1)) SWIG_fail;
2967 {
2968 PyThreadState* __tstate = wxPyBeginAllowThreads();
2969 result = (int)((wxPalette const *)arg1)->GetColoursCount();
2970
2971 wxPyEndAllowThreads(__tstate);
2972 if (PyErr_Occurred()) SWIG_fail;
2973 }
2974 {
2975 resultobj = SWIG_From_int((int)(result));
2976 }
2977 return resultobj;
2978 fail:
2979 return NULL;
2980 }
2981
2982
2983 static PyObject *_wrap_Palette_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
2984 PyObject *resultobj;
2985 wxPalette *arg1 = (wxPalette *) 0 ;
2986 bool result;
2987 PyObject * obj0 = 0 ;
2988 char *kwnames[] = {
2989 (char *) "self", NULL
2990 };
2991
2992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_Ok",kwnames,&obj0)) goto fail;
2993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2994 if (SWIG_arg_fail(1)) SWIG_fail;
2995 {
2996 PyThreadState* __tstate = wxPyBeginAllowThreads();
2997 result = (bool)(arg1)->Ok();
2998
2999 wxPyEndAllowThreads(__tstate);
3000 if (PyErr_Occurred()) SWIG_fail;
3001 }
3002 {
3003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3004 }
3005 return resultobj;
3006 fail:
3007 return NULL;
3008 }
3009
3010
3011 static PyObject * Palette_swigregister(PyObject *, PyObject *args) {
3012 PyObject *obj;
3013 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3014 SWIG_TypeClientData(SWIGTYPE_p_wxPalette, obj);
3015 Py_INCREF(obj);
3016 return Py_BuildValue((char *)"");
3017 }
3018 static PyObject *_wrap_new_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3019 PyObject *resultobj;
3020 wxColour *arg1 = 0 ;
3021 int arg2 = (int) 1 ;
3022 int arg3 = (int) wxSOLID ;
3023 wxPen *result;
3024 wxColour temp1 ;
3025 PyObject * obj0 = 0 ;
3026 PyObject * obj1 = 0 ;
3027 PyObject * obj2 = 0 ;
3028 char *kwnames[] = {
3029 (char *) "colour",(char *) "width",(char *) "style", NULL
3030 };
3031
3032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Pen",kwnames,&obj0,&obj1,&obj2)) goto fail;
3033 {
3034 arg1 = &temp1;
3035 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3036 }
3037 if (obj1) {
3038 {
3039 arg2 = (int)(SWIG_As_int(obj1));
3040 if (SWIG_arg_fail(2)) SWIG_fail;
3041 }
3042 }
3043 if (obj2) {
3044 {
3045 arg3 = (int)(SWIG_As_int(obj2));
3046 if (SWIG_arg_fail(3)) SWIG_fail;
3047 }
3048 }
3049 {
3050 if (!wxPyCheckForApp()) SWIG_fail;
3051 PyThreadState* __tstate = wxPyBeginAllowThreads();
3052 result = (wxPen *)new wxPen(*arg1,arg2,arg3);
3053
3054 wxPyEndAllowThreads(__tstate);
3055 if (PyErr_Occurred()) SWIG_fail;
3056 }
3057 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 1);
3058 return resultobj;
3059 fail:
3060 return NULL;
3061 }
3062
3063
3064 static PyObject *_wrap_delete_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3065 PyObject *resultobj;
3066 wxPen *arg1 = (wxPen *) 0 ;
3067 PyObject * obj0 = 0 ;
3068 char *kwnames[] = {
3069 (char *) "self", NULL
3070 };
3071
3072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Pen",kwnames,&obj0)) goto fail;
3073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3074 if (SWIG_arg_fail(1)) SWIG_fail;
3075 {
3076 PyThreadState* __tstate = wxPyBeginAllowThreads();
3077 delete arg1;
3078
3079 wxPyEndAllowThreads(__tstate);
3080 if (PyErr_Occurred()) SWIG_fail;
3081 }
3082 Py_INCREF(Py_None); resultobj = Py_None;
3083 return resultobj;
3084 fail:
3085 return NULL;
3086 }
3087
3088
3089 static PyObject *_wrap_Pen_GetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3090 PyObject *resultobj;
3091 wxPen *arg1 = (wxPen *) 0 ;
3092 int result;
3093 PyObject * obj0 = 0 ;
3094 char *kwnames[] = {
3095 (char *) "self", NULL
3096 };
3097
3098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetCap",kwnames,&obj0)) goto fail;
3099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3100 if (SWIG_arg_fail(1)) SWIG_fail;
3101 {
3102 PyThreadState* __tstate = wxPyBeginAllowThreads();
3103 result = (int)(arg1)->GetCap();
3104
3105 wxPyEndAllowThreads(__tstate);
3106 if (PyErr_Occurred()) SWIG_fail;
3107 }
3108 {
3109 resultobj = SWIG_From_int((int)(result));
3110 }
3111 return resultobj;
3112 fail:
3113 return NULL;
3114 }
3115
3116
3117 static PyObject *_wrap_Pen_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3118 PyObject *resultobj;
3119 wxPen *arg1 = (wxPen *) 0 ;
3120 wxColour result;
3121 PyObject * obj0 = 0 ;
3122 char *kwnames[] = {
3123 (char *) "self", NULL
3124 };
3125
3126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetColour",kwnames,&obj0)) goto fail;
3127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3128 if (SWIG_arg_fail(1)) SWIG_fail;
3129 {
3130 PyThreadState* __tstate = wxPyBeginAllowThreads();
3131 result = (arg1)->GetColour();
3132
3133 wxPyEndAllowThreads(__tstate);
3134 if (PyErr_Occurred()) SWIG_fail;
3135 }
3136 {
3137 wxColour * resultptr;
3138 resultptr = new wxColour((wxColour &)(result));
3139 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3140 }
3141 return resultobj;
3142 fail:
3143 return NULL;
3144 }
3145
3146
3147 static PyObject *_wrap_Pen_GetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3148 PyObject *resultobj;
3149 wxPen *arg1 = (wxPen *) 0 ;
3150 int result;
3151 PyObject * obj0 = 0 ;
3152 char *kwnames[] = {
3153 (char *) "self", NULL
3154 };
3155
3156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetJoin",kwnames,&obj0)) goto fail;
3157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3158 if (SWIG_arg_fail(1)) SWIG_fail;
3159 {
3160 PyThreadState* __tstate = wxPyBeginAllowThreads();
3161 result = (int)(arg1)->GetJoin();
3162
3163 wxPyEndAllowThreads(__tstate);
3164 if (PyErr_Occurred()) SWIG_fail;
3165 }
3166 {
3167 resultobj = SWIG_From_int((int)(result));
3168 }
3169 return resultobj;
3170 fail:
3171 return NULL;
3172 }
3173
3174
3175 static PyObject *_wrap_Pen_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3176 PyObject *resultobj;
3177 wxPen *arg1 = (wxPen *) 0 ;
3178 int result;
3179 PyObject * obj0 = 0 ;
3180 char *kwnames[] = {
3181 (char *) "self", NULL
3182 };
3183
3184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetStyle",kwnames,&obj0)) goto fail;
3185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3186 if (SWIG_arg_fail(1)) SWIG_fail;
3187 {
3188 PyThreadState* __tstate = wxPyBeginAllowThreads();
3189 result = (int)(arg1)->GetStyle();
3190
3191 wxPyEndAllowThreads(__tstate);
3192 if (PyErr_Occurred()) SWIG_fail;
3193 }
3194 {
3195 resultobj = SWIG_From_int((int)(result));
3196 }
3197 return resultobj;
3198 fail:
3199 return NULL;
3200 }
3201
3202
3203 static PyObject *_wrap_Pen_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3204 PyObject *resultobj;
3205 wxPen *arg1 = (wxPen *) 0 ;
3206 int result;
3207 PyObject * obj0 = 0 ;
3208 char *kwnames[] = {
3209 (char *) "self", NULL
3210 };
3211
3212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetWidth",kwnames,&obj0)) goto fail;
3213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3214 if (SWIG_arg_fail(1)) SWIG_fail;
3215 {
3216 PyThreadState* __tstate = wxPyBeginAllowThreads();
3217 result = (int)(arg1)->GetWidth();
3218
3219 wxPyEndAllowThreads(__tstate);
3220 if (PyErr_Occurred()) SWIG_fail;
3221 }
3222 {
3223 resultobj = SWIG_From_int((int)(result));
3224 }
3225 return resultobj;
3226 fail:
3227 return NULL;
3228 }
3229
3230
3231 static PyObject *_wrap_Pen_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3232 PyObject *resultobj;
3233 wxPen *arg1 = (wxPen *) 0 ;
3234 bool result;
3235 PyObject * obj0 = 0 ;
3236 char *kwnames[] = {
3237 (char *) "self", NULL
3238 };
3239
3240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_Ok",kwnames,&obj0)) goto fail;
3241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3242 if (SWIG_arg_fail(1)) SWIG_fail;
3243 {
3244 PyThreadState* __tstate = wxPyBeginAllowThreads();
3245 result = (bool)(arg1)->Ok();
3246
3247 wxPyEndAllowThreads(__tstate);
3248 if (PyErr_Occurred()) SWIG_fail;
3249 }
3250 {
3251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3252 }
3253 return resultobj;
3254 fail:
3255 return NULL;
3256 }
3257
3258
3259 static PyObject *_wrap_Pen_SetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3260 PyObject *resultobj;
3261 wxPen *arg1 = (wxPen *) 0 ;
3262 int arg2 ;
3263 PyObject * obj0 = 0 ;
3264 PyObject * obj1 = 0 ;
3265 char *kwnames[] = {
3266 (char *) "self",(char *) "cap_style", NULL
3267 };
3268
3269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetCap",kwnames,&obj0,&obj1)) goto fail;
3270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3271 if (SWIG_arg_fail(1)) SWIG_fail;
3272 {
3273 arg2 = (int)(SWIG_As_int(obj1));
3274 if (SWIG_arg_fail(2)) SWIG_fail;
3275 }
3276 {
3277 PyThreadState* __tstate = wxPyBeginAllowThreads();
3278 (arg1)->SetCap(arg2);
3279
3280 wxPyEndAllowThreads(__tstate);
3281 if (PyErr_Occurred()) SWIG_fail;
3282 }
3283 Py_INCREF(Py_None); resultobj = Py_None;
3284 return resultobj;
3285 fail:
3286 return NULL;
3287 }
3288
3289
3290 static PyObject *_wrap_Pen_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3291 PyObject *resultobj;
3292 wxPen *arg1 = (wxPen *) 0 ;
3293 wxColour *arg2 = 0 ;
3294 wxColour temp2 ;
3295 PyObject * obj0 = 0 ;
3296 PyObject * obj1 = 0 ;
3297 char *kwnames[] = {
3298 (char *) "self",(char *) "colour", NULL
3299 };
3300
3301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetColour",kwnames,&obj0,&obj1)) goto fail;
3302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3303 if (SWIG_arg_fail(1)) SWIG_fail;
3304 {
3305 arg2 = &temp2;
3306 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3307 }
3308 {
3309 PyThreadState* __tstate = wxPyBeginAllowThreads();
3310 (arg1)->SetColour(*arg2);
3311
3312 wxPyEndAllowThreads(__tstate);
3313 if (PyErr_Occurred()) SWIG_fail;
3314 }
3315 Py_INCREF(Py_None); resultobj = Py_None;
3316 return resultobj;
3317 fail:
3318 return NULL;
3319 }
3320
3321
3322 static PyObject *_wrap_Pen_SetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3323 PyObject *resultobj;
3324 wxPen *arg1 = (wxPen *) 0 ;
3325 int arg2 ;
3326 PyObject * obj0 = 0 ;
3327 PyObject * obj1 = 0 ;
3328 char *kwnames[] = {
3329 (char *) "self",(char *) "join_style", NULL
3330 };
3331
3332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetJoin",kwnames,&obj0,&obj1)) goto fail;
3333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3334 if (SWIG_arg_fail(1)) SWIG_fail;
3335 {
3336 arg2 = (int)(SWIG_As_int(obj1));
3337 if (SWIG_arg_fail(2)) SWIG_fail;
3338 }
3339 {
3340 PyThreadState* __tstate = wxPyBeginAllowThreads();
3341 (arg1)->SetJoin(arg2);
3342
3343 wxPyEndAllowThreads(__tstate);
3344 if (PyErr_Occurred()) SWIG_fail;
3345 }
3346 Py_INCREF(Py_None); resultobj = Py_None;
3347 return resultobj;
3348 fail:
3349 return NULL;
3350 }
3351
3352
3353 static PyObject *_wrap_Pen_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3354 PyObject *resultobj;
3355 wxPen *arg1 = (wxPen *) 0 ;
3356 int arg2 ;
3357 PyObject * obj0 = 0 ;
3358 PyObject * obj1 = 0 ;
3359 char *kwnames[] = {
3360 (char *) "self",(char *) "style", NULL
3361 };
3362
3363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3365 if (SWIG_arg_fail(1)) SWIG_fail;
3366 {
3367 arg2 = (int)(SWIG_As_int(obj1));
3368 if (SWIG_arg_fail(2)) SWIG_fail;
3369 }
3370 {
3371 PyThreadState* __tstate = wxPyBeginAllowThreads();
3372 (arg1)->SetStyle(arg2);
3373
3374 wxPyEndAllowThreads(__tstate);
3375 if (PyErr_Occurred()) SWIG_fail;
3376 }
3377 Py_INCREF(Py_None); resultobj = Py_None;
3378 return resultobj;
3379 fail:
3380 return NULL;
3381 }
3382
3383
3384 static PyObject *_wrap_Pen_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3385 PyObject *resultobj;
3386 wxPen *arg1 = (wxPen *) 0 ;
3387 int arg2 ;
3388 PyObject * obj0 = 0 ;
3389 PyObject * obj1 = 0 ;
3390 char *kwnames[] = {
3391 (char *) "self",(char *) "width", NULL
3392 };
3393
3394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3396 if (SWIG_arg_fail(1)) SWIG_fail;
3397 {
3398 arg2 = (int)(SWIG_As_int(obj1));
3399 if (SWIG_arg_fail(2)) SWIG_fail;
3400 }
3401 {
3402 PyThreadState* __tstate = wxPyBeginAllowThreads();
3403 (arg1)->SetWidth(arg2);
3404
3405 wxPyEndAllowThreads(__tstate);
3406 if (PyErr_Occurred()) SWIG_fail;
3407 }
3408 Py_INCREF(Py_None); resultobj = Py_None;
3409 return resultobj;
3410 fail:
3411 return NULL;
3412 }
3413
3414
3415 static PyObject *_wrap_Pen_SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3416 PyObject *resultobj;
3417 wxPen *arg1 = (wxPen *) 0 ;
3418 int arg2 ;
3419 wxDash *arg3 = (wxDash *) 0 ;
3420 PyObject * obj0 = 0 ;
3421 PyObject * obj1 = 0 ;
3422 char *kwnames[] = {
3423 (char *) "self",(char *) "dashes", NULL
3424 };
3425
3426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetDashes",kwnames,&obj0,&obj1)) goto fail;
3427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3428 if (SWIG_arg_fail(1)) SWIG_fail;
3429 {
3430 arg2 = PyList_Size(obj1);
3431 arg3 = (wxDash*)byte_LIST_helper(obj1);
3432 if (arg3 == NULL) SWIG_fail;
3433 }
3434 {
3435 PyThreadState* __tstate = wxPyBeginAllowThreads();
3436 (arg1)->SetDashes(arg2,arg3);
3437
3438 wxPyEndAllowThreads(__tstate);
3439 if (PyErr_Occurred()) SWIG_fail;
3440 }
3441 Py_INCREF(Py_None); resultobj = Py_None;
3442 {
3443 if (arg3) delete [] arg3;
3444 }
3445 return resultobj;
3446 fail:
3447 {
3448 if (arg3) delete [] arg3;
3449 }
3450 return NULL;
3451 }
3452
3453
3454 static PyObject *_wrap_Pen_GetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3455 PyObject *resultobj;
3456 wxPen *arg1 = (wxPen *) 0 ;
3457 PyObject *result;
3458 PyObject * obj0 = 0 ;
3459 char *kwnames[] = {
3460 (char *) "self", NULL
3461 };
3462
3463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashes",kwnames,&obj0)) goto fail;
3464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3465 if (SWIG_arg_fail(1)) SWIG_fail;
3466 {
3467 PyThreadState* __tstate = wxPyBeginAllowThreads();
3468 result = (PyObject *)wxPen_GetDashes(arg1);
3469
3470 wxPyEndAllowThreads(__tstate);
3471 if (PyErr_Occurred()) SWIG_fail;
3472 }
3473 resultobj = result;
3474 return resultobj;
3475 fail:
3476 return NULL;
3477 }
3478
3479
3480 static PyObject *_wrap_Pen__SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3481 PyObject *resultobj;
3482 wxPen *arg1 = (wxPen *) 0 ;
3483 PyObject *arg2 = (PyObject *) 0 ;
3484 PyObject *arg3 = (PyObject *) 0 ;
3485 PyObject * obj0 = 0 ;
3486 PyObject * obj1 = 0 ;
3487 PyObject * obj2 = 0 ;
3488 char *kwnames[] = {
3489 (char *) "self",(char *) "_self",(char *) "pyDashes", NULL
3490 };
3491
3492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Pen__SetDashes",kwnames,&obj0,&obj1,&obj2)) goto fail;
3493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3494 if (SWIG_arg_fail(1)) SWIG_fail;
3495 arg2 = obj1;
3496 arg3 = obj2;
3497 {
3498 PyThreadState* __tstate = wxPyBeginAllowThreads();
3499 wxPen__SetDashes(arg1,arg2,arg3);
3500
3501 wxPyEndAllowThreads(__tstate);
3502 if (PyErr_Occurred()) SWIG_fail;
3503 }
3504 Py_INCREF(Py_None); resultobj = Py_None;
3505 return resultobj;
3506 fail:
3507 return NULL;
3508 }
3509
3510
3511 static PyObject *_wrap_Pen_GetDashCount(PyObject *, PyObject *args, PyObject *kwargs) {
3512 PyObject *resultobj;
3513 wxPen *arg1 = (wxPen *) 0 ;
3514 int result;
3515 PyObject * obj0 = 0 ;
3516 char *kwnames[] = {
3517 (char *) "self", NULL
3518 };
3519
3520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashCount",kwnames,&obj0)) goto fail;
3521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3522 if (SWIG_arg_fail(1)) SWIG_fail;
3523 {
3524 PyThreadState* __tstate = wxPyBeginAllowThreads();
3525 result = (int)((wxPen const *)arg1)->GetDashCount();
3526
3527 wxPyEndAllowThreads(__tstate);
3528 if (PyErr_Occurred()) SWIG_fail;
3529 }
3530 {
3531 resultobj = SWIG_From_int((int)(result));
3532 }
3533 return resultobj;
3534 fail:
3535 return NULL;
3536 }
3537
3538
3539 static PyObject *_wrap_Pen_GetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3540 PyObject *resultobj;
3541 wxPen *arg1 = (wxPen *) 0 ;
3542 wxBitmap *result;
3543 PyObject * obj0 = 0 ;
3544 char *kwnames[] = {
3545 (char *) "self", NULL
3546 };
3547
3548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetStipple",kwnames,&obj0)) goto fail;
3549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3550 if (SWIG_arg_fail(1)) SWIG_fail;
3551 {
3552 PyThreadState* __tstate = wxPyBeginAllowThreads();
3553 result = (wxBitmap *)(arg1)->GetStipple();
3554
3555 wxPyEndAllowThreads(__tstate);
3556 if (PyErr_Occurred()) SWIG_fail;
3557 }
3558 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 0);
3559 return resultobj;
3560 fail:
3561 return NULL;
3562 }
3563
3564
3565 static PyObject *_wrap_Pen_SetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3566 PyObject *resultobj;
3567 wxPen *arg1 = (wxPen *) 0 ;
3568 wxBitmap *arg2 = 0 ;
3569 PyObject * obj0 = 0 ;
3570 PyObject * obj1 = 0 ;
3571 char *kwnames[] = {
3572 (char *) "self",(char *) "stipple", NULL
3573 };
3574
3575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStipple",kwnames,&obj0,&obj1)) goto fail;
3576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3577 if (SWIG_arg_fail(1)) SWIG_fail;
3578 {
3579 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3580 if (SWIG_arg_fail(2)) SWIG_fail;
3581 if (arg2 == NULL) {
3582 SWIG_null_ref("wxBitmap");
3583 }
3584 if (SWIG_arg_fail(2)) SWIG_fail;
3585 }
3586 {
3587 PyThreadState* __tstate = wxPyBeginAllowThreads();
3588 (arg1)->SetStipple(*arg2);
3589
3590 wxPyEndAllowThreads(__tstate);
3591 if (PyErr_Occurred()) SWIG_fail;
3592 }
3593 Py_INCREF(Py_None); resultobj = Py_None;
3594 return resultobj;
3595 fail:
3596 return NULL;
3597 }
3598
3599
3600 static PyObject *_wrap_Pen___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3601 PyObject *resultobj;
3602 wxPen *arg1 = (wxPen *) 0 ;
3603 wxPen *arg2 = (wxPen *) 0 ;
3604 bool result;
3605 PyObject * obj0 = 0 ;
3606 PyObject * obj1 = 0 ;
3607 char *kwnames[] = {
3608 (char *) "self",(char *) "other", NULL
3609 };
3610
3611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___eq__",kwnames,&obj0,&obj1)) goto fail;
3612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3613 if (SWIG_arg_fail(1)) SWIG_fail;
3614 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3615 if (SWIG_arg_fail(2)) SWIG_fail;
3616 {
3617 PyThreadState* __tstate = wxPyBeginAllowThreads();
3618 result = (bool)wxPen___eq__(arg1,(wxPen const *)arg2);
3619
3620 wxPyEndAllowThreads(__tstate);
3621 if (PyErr_Occurred()) SWIG_fail;
3622 }
3623 {
3624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3625 }
3626 return resultobj;
3627 fail:
3628 return NULL;
3629 }
3630
3631
3632 static PyObject *_wrap_Pen___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3633 PyObject *resultobj;
3634 wxPen *arg1 = (wxPen *) 0 ;
3635 wxPen *arg2 = (wxPen *) 0 ;
3636 bool result;
3637 PyObject * obj0 = 0 ;
3638 PyObject * obj1 = 0 ;
3639 char *kwnames[] = {
3640 (char *) "self",(char *) "other", NULL
3641 };
3642
3643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___ne__",kwnames,&obj0,&obj1)) goto fail;
3644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3645 if (SWIG_arg_fail(1)) SWIG_fail;
3646 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3647 if (SWIG_arg_fail(2)) SWIG_fail;
3648 {
3649 PyThreadState* __tstate = wxPyBeginAllowThreads();
3650 result = (bool)wxPen___ne__(arg1,(wxPen const *)arg2);
3651
3652 wxPyEndAllowThreads(__tstate);
3653 if (PyErr_Occurred()) SWIG_fail;
3654 }
3655 {
3656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3657 }
3658 return resultobj;
3659 fail:
3660 return NULL;
3661 }
3662
3663
3664 static PyObject * Pen_swigregister(PyObject *, PyObject *args) {
3665 PyObject *obj;
3666 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3667 SWIG_TypeClientData(SWIGTYPE_p_wxPen, obj);
3668 Py_INCREF(obj);
3669 return Py_BuildValue((char *)"");
3670 }
3671 static PyObject *_wrap_new_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3672 PyObject *resultobj;
3673 wxColour *arg1 = 0 ;
3674 int arg2 = (int) wxSOLID ;
3675 wxBrush *result;
3676 wxColour temp1 ;
3677 PyObject * obj0 = 0 ;
3678 PyObject * obj1 = 0 ;
3679 char *kwnames[] = {
3680 (char *) "colour",(char *) "style", NULL
3681 };
3682
3683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Brush",kwnames,&obj0,&obj1)) goto fail;
3684 {
3685 arg1 = &temp1;
3686 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3687 }
3688 if (obj1) {
3689 {
3690 arg2 = (int)(SWIG_As_int(obj1));
3691 if (SWIG_arg_fail(2)) SWIG_fail;
3692 }
3693 }
3694 {
3695 if (!wxPyCheckForApp()) SWIG_fail;
3696 PyThreadState* __tstate = wxPyBeginAllowThreads();
3697 result = (wxBrush *)new wxBrush((wxColour const &)*arg1,arg2);
3698
3699 wxPyEndAllowThreads(__tstate);
3700 if (PyErr_Occurred()) SWIG_fail;
3701 }
3702 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 1);
3703 return resultobj;
3704 fail:
3705 return NULL;
3706 }
3707
3708
3709 static PyObject *_wrap_delete_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3710 PyObject *resultobj;
3711 wxBrush *arg1 = (wxBrush *) 0 ;
3712 PyObject * obj0 = 0 ;
3713 char *kwnames[] = {
3714 (char *) "self", NULL
3715 };
3716
3717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Brush",kwnames,&obj0)) goto fail;
3718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3719 if (SWIG_arg_fail(1)) SWIG_fail;
3720 {
3721 PyThreadState* __tstate = wxPyBeginAllowThreads();
3722 delete arg1;
3723
3724 wxPyEndAllowThreads(__tstate);
3725 if (PyErr_Occurred()) SWIG_fail;
3726 }
3727 Py_INCREF(Py_None); resultobj = Py_None;
3728 return resultobj;
3729 fail:
3730 return NULL;
3731 }
3732
3733
3734 static PyObject *_wrap_Brush_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3735 PyObject *resultobj;
3736 wxBrush *arg1 = (wxBrush *) 0 ;
3737 wxColour *arg2 = 0 ;
3738 wxColour temp2 ;
3739 PyObject * obj0 = 0 ;
3740 PyObject * obj1 = 0 ;
3741 char *kwnames[] = {
3742 (char *) "self",(char *) "col", NULL
3743 };
3744
3745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetColour",kwnames,&obj0,&obj1)) goto fail;
3746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3747 if (SWIG_arg_fail(1)) SWIG_fail;
3748 {
3749 arg2 = &temp2;
3750 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3751 }
3752 {
3753 PyThreadState* __tstate = wxPyBeginAllowThreads();
3754 (arg1)->SetColour((wxColour const &)*arg2);
3755
3756 wxPyEndAllowThreads(__tstate);
3757 if (PyErr_Occurred()) SWIG_fail;
3758 }
3759 Py_INCREF(Py_None); resultobj = Py_None;
3760 return resultobj;
3761 fail:
3762 return NULL;
3763 }
3764
3765
3766 static PyObject *_wrap_Brush_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3767 PyObject *resultobj;
3768 wxBrush *arg1 = (wxBrush *) 0 ;
3769 int arg2 ;
3770 PyObject * obj0 = 0 ;
3771 PyObject * obj1 = 0 ;
3772 char *kwnames[] = {
3773 (char *) "self",(char *) "style", NULL
3774 };
3775
3776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3778 if (SWIG_arg_fail(1)) SWIG_fail;
3779 {
3780 arg2 = (int)(SWIG_As_int(obj1));
3781 if (SWIG_arg_fail(2)) SWIG_fail;
3782 }
3783 {
3784 PyThreadState* __tstate = wxPyBeginAllowThreads();
3785 (arg1)->SetStyle(arg2);
3786
3787 wxPyEndAllowThreads(__tstate);
3788 if (PyErr_Occurred()) SWIG_fail;
3789 }
3790 Py_INCREF(Py_None); resultobj = Py_None;
3791 return resultobj;
3792 fail:
3793 return NULL;
3794 }
3795
3796
3797 static PyObject *_wrap_Brush_SetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3798 PyObject *resultobj;
3799 wxBrush *arg1 = (wxBrush *) 0 ;
3800 wxBitmap *arg2 = 0 ;
3801 PyObject * obj0 = 0 ;
3802 PyObject * obj1 = 0 ;
3803 char *kwnames[] = {
3804 (char *) "self",(char *) "stipple", NULL
3805 };
3806
3807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStipple",kwnames,&obj0,&obj1)) goto fail;
3808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3809 if (SWIG_arg_fail(1)) SWIG_fail;
3810 {
3811 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3812 if (SWIG_arg_fail(2)) SWIG_fail;
3813 if (arg2 == NULL) {
3814 SWIG_null_ref("wxBitmap");
3815 }
3816 if (SWIG_arg_fail(2)) SWIG_fail;
3817 }
3818 {
3819 PyThreadState* __tstate = wxPyBeginAllowThreads();
3820 (arg1)->SetStipple((wxBitmap const &)*arg2);
3821
3822 wxPyEndAllowThreads(__tstate);
3823 if (PyErr_Occurred()) SWIG_fail;
3824 }
3825 Py_INCREF(Py_None); resultobj = Py_None;
3826 return resultobj;
3827 fail:
3828 return NULL;
3829 }
3830
3831
3832 static PyObject *_wrap_Brush_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3833 PyObject *resultobj;
3834 wxBrush *arg1 = (wxBrush *) 0 ;
3835 wxColour result;
3836 PyObject * obj0 = 0 ;
3837 char *kwnames[] = {
3838 (char *) "self", NULL
3839 };
3840
3841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetColour",kwnames,&obj0)) goto fail;
3842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3843 if (SWIG_arg_fail(1)) SWIG_fail;
3844 {
3845 PyThreadState* __tstate = wxPyBeginAllowThreads();
3846 result = ((wxBrush const *)arg1)->GetColour();
3847
3848 wxPyEndAllowThreads(__tstate);
3849 if (PyErr_Occurred()) SWIG_fail;
3850 }
3851 {
3852 wxColour * resultptr;
3853 resultptr = new wxColour((wxColour &)(result));
3854 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3855 }
3856 return resultobj;
3857 fail:
3858 return NULL;
3859 }
3860
3861
3862 static PyObject *_wrap_Brush_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3863 PyObject *resultobj;
3864 wxBrush *arg1 = (wxBrush *) 0 ;
3865 int result;
3866 PyObject * obj0 = 0 ;
3867 char *kwnames[] = {
3868 (char *) "self", NULL
3869 };
3870
3871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStyle",kwnames,&obj0)) goto fail;
3872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3873 if (SWIG_arg_fail(1)) SWIG_fail;
3874 {
3875 PyThreadState* __tstate = wxPyBeginAllowThreads();
3876 result = (int)((wxBrush const *)arg1)->GetStyle();
3877
3878 wxPyEndAllowThreads(__tstate);
3879 if (PyErr_Occurred()) SWIG_fail;
3880 }
3881 {
3882 resultobj = SWIG_From_int((int)(result));
3883 }
3884 return resultobj;
3885 fail:
3886 return NULL;
3887 }
3888
3889
3890 static PyObject *_wrap_Brush_GetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3891 PyObject *resultobj;
3892 wxBrush *arg1 = (wxBrush *) 0 ;
3893 wxBitmap *result;
3894 PyObject * obj0 = 0 ;
3895 char *kwnames[] = {
3896 (char *) "self", NULL
3897 };
3898
3899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStipple",kwnames,&obj0)) goto fail;
3900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3901 if (SWIG_arg_fail(1)) SWIG_fail;
3902 {
3903 PyThreadState* __tstate = wxPyBeginAllowThreads();
3904 result = (wxBitmap *)((wxBrush const *)arg1)->GetStipple();
3905
3906 wxPyEndAllowThreads(__tstate);
3907 if (PyErr_Occurred()) SWIG_fail;
3908 }
3909 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 0);
3910 return resultobj;
3911 fail:
3912 return NULL;
3913 }
3914
3915
3916 static PyObject *_wrap_Brush_IsHatch(PyObject *, PyObject *args, PyObject *kwargs) {
3917 PyObject *resultobj;
3918 wxBrush *arg1 = (wxBrush *) 0 ;
3919 bool result;
3920 PyObject * obj0 = 0 ;
3921 char *kwnames[] = {
3922 (char *) "self", NULL
3923 };
3924
3925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_IsHatch",kwnames,&obj0)) goto fail;
3926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3927 if (SWIG_arg_fail(1)) SWIG_fail;
3928 {
3929 PyThreadState* __tstate = wxPyBeginAllowThreads();
3930 result = (bool)((wxBrush const *)arg1)->IsHatch();
3931
3932 wxPyEndAllowThreads(__tstate);
3933 if (PyErr_Occurred()) SWIG_fail;
3934 }
3935 {
3936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3937 }
3938 return resultobj;
3939 fail:
3940 return NULL;
3941 }
3942
3943
3944 static PyObject *_wrap_Brush_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3945 PyObject *resultobj;
3946 wxBrush *arg1 = (wxBrush *) 0 ;
3947 bool result;
3948 PyObject * obj0 = 0 ;
3949 char *kwnames[] = {
3950 (char *) "self", NULL
3951 };
3952
3953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_Ok",kwnames,&obj0)) goto fail;
3954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3955 if (SWIG_arg_fail(1)) SWIG_fail;
3956 {
3957 PyThreadState* __tstate = wxPyBeginAllowThreads();
3958 result = (bool)(arg1)->Ok();
3959
3960 wxPyEndAllowThreads(__tstate);
3961 if (PyErr_Occurred()) SWIG_fail;
3962 }
3963 {
3964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3965 }
3966 return resultobj;
3967 fail:
3968 return NULL;
3969 }
3970
3971
3972 static PyObject * Brush_swigregister(PyObject *, PyObject *args) {
3973 PyObject *obj;
3974 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3975 SWIG_TypeClientData(SWIGTYPE_p_wxBrush, obj);
3976 Py_INCREF(obj);
3977 return Py_BuildValue((char *)"");
3978 }
3979 static PyObject *_wrap_new_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
3980 PyObject *resultobj;
3981 wxString *arg1 = 0 ;
3982 wxBitmapType arg2 = (wxBitmapType) wxBITMAP_TYPE_ANY ;
3983 wxBitmap *result;
3984 bool temp1 = false ;
3985 PyObject * obj0 = 0 ;
3986 PyObject * obj1 = 0 ;
3987 char *kwnames[] = {
3988 (char *) "name",(char *) "type", NULL
3989 };
3990
3991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Bitmap",kwnames,&obj0,&obj1)) goto fail;
3992 {
3993 arg1 = wxString_in_helper(obj0);
3994 if (arg1 == NULL) SWIG_fail;
3995 temp1 = true;
3996 }
3997 if (obj1) {
3998 {
3999 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
4000 if (SWIG_arg_fail(2)) SWIG_fail;
4001 }
4002 }
4003 {
4004 if (!wxPyCheckForApp()) SWIG_fail;
4005 PyThreadState* __tstate = wxPyBeginAllowThreads();
4006 result = (wxBitmap *)new wxBitmap((wxString const &)*arg1,(wxBitmapType )arg2);
4007
4008 wxPyEndAllowThreads(__tstate);
4009 if (PyErr_Occurred()) SWIG_fail;
4010 }
4011 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4012 {
4013 if (temp1)
4014 delete arg1;
4015 }
4016 return resultobj;
4017 fail:
4018 {
4019 if (temp1)
4020 delete arg1;
4021 }
4022 return NULL;
4023 }
4024
4025
4026 static PyObject *_wrap_delete_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4027 PyObject *resultobj;
4028 wxBitmap *arg1 = (wxBitmap *) 0 ;
4029 PyObject * obj0 = 0 ;
4030 char *kwnames[] = {
4031 (char *) "self", NULL
4032 };
4033
4034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Bitmap",kwnames,&obj0)) goto fail;
4035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4036 if (SWIG_arg_fail(1)) SWIG_fail;
4037 {
4038 PyThreadState* __tstate = wxPyBeginAllowThreads();
4039 delete arg1;
4040
4041 wxPyEndAllowThreads(__tstate);
4042 if (PyErr_Occurred()) SWIG_fail;
4043 }
4044 Py_INCREF(Py_None); resultobj = Py_None;
4045 return resultobj;
4046 fail:
4047 return NULL;
4048 }
4049
4050
4051 static PyObject *_wrap_new_EmptyBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4052 PyObject *resultobj;
4053 int arg1 ;
4054 int arg2 ;
4055 int arg3 = (int) -1 ;
4056 wxBitmap *result;
4057 PyObject * obj0 = 0 ;
4058 PyObject * obj1 = 0 ;
4059 PyObject * obj2 = 0 ;
4060 char *kwnames[] = {
4061 (char *) "width",(char *) "height",(char *) "depth", NULL
4062 };
4063
4064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_EmptyBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
4065 {
4066 arg1 = (int)(SWIG_As_int(obj0));
4067 if (SWIG_arg_fail(1)) SWIG_fail;
4068 }
4069 {
4070 arg2 = (int)(SWIG_As_int(obj1));
4071 if (SWIG_arg_fail(2)) SWIG_fail;
4072 }
4073 if (obj2) {
4074 {
4075 arg3 = (int)(SWIG_As_int(obj2));
4076 if (SWIG_arg_fail(3)) SWIG_fail;
4077 }
4078 }
4079 {
4080 if (!wxPyCheckForApp()) SWIG_fail;
4081 PyThreadState* __tstate = wxPyBeginAllowThreads();
4082 result = (wxBitmap *)new wxBitmap(arg1,arg2,arg3);
4083
4084 wxPyEndAllowThreads(__tstate);
4085 if (PyErr_Occurred()) SWIG_fail;
4086 }
4087 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4088 return resultobj;
4089 fail:
4090 return NULL;
4091 }
4092
4093
4094 static PyObject *_wrap_new_BitmapFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4095 PyObject *resultobj;
4096 wxIcon *arg1 = 0 ;
4097 wxBitmap *result;
4098 PyObject * obj0 = 0 ;
4099 char *kwnames[] = {
4100 (char *) "icon", NULL
4101 };
4102
4103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromIcon",kwnames,&obj0)) goto fail;
4104 {
4105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4106 if (SWIG_arg_fail(1)) SWIG_fail;
4107 if (arg1 == NULL) {
4108 SWIG_null_ref("wxIcon");
4109 }
4110 if (SWIG_arg_fail(1)) SWIG_fail;
4111 }
4112 {
4113 if (!wxPyCheckForApp()) SWIG_fail;
4114 PyThreadState* __tstate = wxPyBeginAllowThreads();
4115 result = (wxBitmap *)new wxBitmap((wxIcon const &)*arg1);
4116
4117 wxPyEndAllowThreads(__tstate);
4118 if (PyErr_Occurred()) SWIG_fail;
4119 }
4120 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4121 return resultobj;
4122 fail:
4123 return NULL;
4124 }
4125
4126
4127 static PyObject *_wrap_new_BitmapFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
4128 PyObject *resultobj;
4129 wxImage *arg1 = 0 ;
4130 int arg2 = (int) -1 ;
4131 wxBitmap *result;
4132 PyObject * obj0 = 0 ;
4133 PyObject * obj1 = 0 ;
4134 char *kwnames[] = {
4135 (char *) "image",(char *) "depth", NULL
4136 };
4137
4138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BitmapFromImage",kwnames,&obj0,&obj1)) goto fail;
4139 {
4140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
4141 if (SWIG_arg_fail(1)) SWIG_fail;
4142 if (arg1 == NULL) {
4143 SWIG_null_ref("wxImage");
4144 }
4145 if (SWIG_arg_fail(1)) SWIG_fail;
4146 }
4147 if (obj1) {
4148 {
4149 arg2 = (int)(SWIG_As_int(obj1));
4150 if (SWIG_arg_fail(2)) SWIG_fail;
4151 }
4152 }
4153 {
4154 if (!wxPyCheckForApp()) SWIG_fail;
4155 PyThreadState* __tstate = wxPyBeginAllowThreads();
4156 result = (wxBitmap *)new wxBitmap((wxImage const &)*arg1,arg2);
4157
4158 wxPyEndAllowThreads(__tstate);
4159 if (PyErr_Occurred()) SWIG_fail;
4160 }
4161 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4162 return resultobj;
4163 fail:
4164 return NULL;
4165 }
4166
4167
4168 static PyObject *_wrap_new_BitmapFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
4169 PyObject *resultobj;
4170 PyObject *arg1 = (PyObject *) 0 ;
4171 wxBitmap *result;
4172 PyObject * obj0 = 0 ;
4173 char *kwnames[] = {
4174 (char *) "listOfStrings", NULL
4175 };
4176
4177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromXPMData",kwnames,&obj0)) goto fail;
4178 arg1 = obj0;
4179 {
4180 if (!wxPyCheckForApp()) SWIG_fail;
4181 PyThreadState* __tstate = wxPyBeginAllowThreads();
4182 result = (wxBitmap *)new_wxBitmap(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_BitmapFromBits(PyObject *, PyObject *args, PyObject *kwargs) {
4195 PyObject *resultobj;
4196 PyObject *arg1 = (PyObject *) 0 ;
4197 int arg2 ;
4198 int arg3 ;
4199 int arg4 = (int) 1 ;
4200 wxBitmap *result;
4201 PyObject * obj0 = 0 ;
4202 PyObject * obj1 = 0 ;
4203 PyObject * obj2 = 0 ;
4204 PyObject * obj3 = 0 ;
4205 char *kwnames[] = {
4206 (char *) "bits",(char *) "width",(char *) "height",(char *) "depth", NULL
4207 };
4208
4209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:new_BitmapFromBits",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4210 arg1 = obj0;
4211 {
4212 arg2 = (int)(SWIG_As_int(obj1));
4213 if (SWIG_arg_fail(2)) SWIG_fail;
4214 }
4215 {
4216 arg3 = (int)(SWIG_As_int(obj2));
4217 if (SWIG_arg_fail(3)) SWIG_fail;
4218 }
4219 if (obj3) {
4220 {
4221 arg4 = (int)(SWIG_As_int(obj3));
4222 if (SWIG_arg_fail(4)) SWIG_fail;
4223 }
4224 }
4225 {
4226 if (!wxPyCheckForApp()) SWIG_fail;
4227 PyThreadState* __tstate = wxPyBeginAllowThreads();
4228 result = (wxBitmap *)new_wxBitmap(arg1,arg2,arg3,arg4);
4229
4230 wxPyEndAllowThreads(__tstate);
4231 if (PyErr_Occurred()) SWIG_fail;
4232 }
4233 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4234 return resultobj;
4235 fail:
4236 return NULL;
4237 }
4238
4239
4240 static PyObject *_wrap_Bitmap_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
4241 PyObject *resultobj;
4242 wxBitmap *arg1 = (wxBitmap *) 0 ;
4243 long result;
4244 PyObject * obj0 = 0 ;
4245 char *kwnames[] = {
4246 (char *) "self", NULL
4247 };
4248
4249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetHandle",kwnames,&obj0)) goto fail;
4250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4251 if (SWIG_arg_fail(1)) SWIG_fail;
4252 {
4253 PyThreadState* __tstate = wxPyBeginAllowThreads();
4254 result = (long)(arg1)->GetHandle();
4255
4256 wxPyEndAllowThreads(__tstate);
4257 if (PyErr_Occurred()) SWIG_fail;
4258 }
4259 {
4260 resultobj = SWIG_From_long((long)(result));
4261 }
4262 return resultobj;
4263 fail:
4264 return NULL;
4265 }
4266
4267
4268 static PyObject *_wrap_Bitmap_SetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
4269 PyObject *resultobj;
4270 wxBitmap *arg1 = (wxBitmap *) 0 ;
4271 long arg2 ;
4272 PyObject * obj0 = 0 ;
4273 PyObject * obj1 = 0 ;
4274 char *kwnames[] = {
4275 (char *) "self",(char *) "handle", NULL
4276 };
4277
4278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHandle",kwnames,&obj0,&obj1)) goto fail;
4279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4280 if (SWIG_arg_fail(1)) SWIG_fail;
4281 {
4282 arg2 = (long)(SWIG_As_long(obj1));
4283 if (SWIG_arg_fail(2)) SWIG_fail;
4284 }
4285 {
4286 PyThreadState* __tstate = wxPyBeginAllowThreads();
4287 wxBitmap_SetHandle(arg1,arg2);
4288
4289 wxPyEndAllowThreads(__tstate);
4290 if (PyErr_Occurred()) SWIG_fail;
4291 }
4292 Py_INCREF(Py_None); resultobj = Py_None;
4293 return resultobj;
4294 fail:
4295 return NULL;
4296 }
4297
4298
4299 static PyObject *_wrap_Bitmap_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
4300 PyObject *resultobj;
4301 wxBitmap *arg1 = (wxBitmap *) 0 ;
4302 bool result;
4303 PyObject * obj0 = 0 ;
4304 char *kwnames[] = {
4305 (char *) "self", NULL
4306 };
4307
4308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_Ok",kwnames,&obj0)) goto fail;
4309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4310 if (SWIG_arg_fail(1)) SWIG_fail;
4311 {
4312 PyThreadState* __tstate = wxPyBeginAllowThreads();
4313 result = (bool)(arg1)->Ok();
4314
4315 wxPyEndAllowThreads(__tstate);
4316 if (PyErr_Occurred()) SWIG_fail;
4317 }
4318 {
4319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4320 }
4321 return resultobj;
4322 fail:
4323 return NULL;
4324 }
4325
4326
4327 static PyObject *_wrap_Bitmap_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4328 PyObject *resultobj;
4329 wxBitmap *arg1 = (wxBitmap *) 0 ;
4330 int result;
4331 PyObject * obj0 = 0 ;
4332 char *kwnames[] = {
4333 (char *) "self", NULL
4334 };
4335
4336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetWidth",kwnames,&obj0)) goto fail;
4337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4338 if (SWIG_arg_fail(1)) SWIG_fail;
4339 {
4340 PyThreadState* __tstate = wxPyBeginAllowThreads();
4341 result = (int)(arg1)->GetWidth();
4342
4343 wxPyEndAllowThreads(__tstate);
4344 if (PyErr_Occurred()) SWIG_fail;
4345 }
4346 {
4347 resultobj = SWIG_From_int((int)(result));
4348 }
4349 return resultobj;
4350 fail:
4351 return NULL;
4352 }
4353
4354
4355 static PyObject *_wrap_Bitmap_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4356 PyObject *resultobj;
4357 wxBitmap *arg1 = (wxBitmap *) 0 ;
4358 int result;
4359 PyObject * obj0 = 0 ;
4360 char *kwnames[] = {
4361 (char *) "self", NULL
4362 };
4363
4364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetHeight",kwnames,&obj0)) goto fail;
4365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4366 if (SWIG_arg_fail(1)) SWIG_fail;
4367 {
4368 PyThreadState* __tstate = wxPyBeginAllowThreads();
4369 result = (int)(arg1)->GetHeight();
4370
4371 wxPyEndAllowThreads(__tstate);
4372 if (PyErr_Occurred()) SWIG_fail;
4373 }
4374 {
4375 resultobj = SWIG_From_int((int)(result));
4376 }
4377 return resultobj;
4378 fail:
4379 return NULL;
4380 }
4381
4382
4383 static PyObject *_wrap_Bitmap_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4384 PyObject *resultobj;
4385 wxBitmap *arg1 = (wxBitmap *) 0 ;
4386 int result;
4387 PyObject * obj0 = 0 ;
4388 char *kwnames[] = {
4389 (char *) "self", NULL
4390 };
4391
4392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetDepth",kwnames,&obj0)) goto fail;
4393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4394 if (SWIG_arg_fail(1)) SWIG_fail;
4395 {
4396 PyThreadState* __tstate = wxPyBeginAllowThreads();
4397 result = (int)(arg1)->GetDepth();
4398
4399 wxPyEndAllowThreads(__tstate);
4400 if (PyErr_Occurred()) SWIG_fail;
4401 }
4402 {
4403 resultobj = SWIG_From_int((int)(result));
4404 }
4405 return resultobj;
4406 fail:
4407 return NULL;
4408 }
4409
4410
4411 static PyObject *_wrap_Bitmap_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4412 PyObject *resultobj;
4413 wxBitmap *arg1 = (wxBitmap *) 0 ;
4414 wxSize result;
4415 PyObject * obj0 = 0 ;
4416 char *kwnames[] = {
4417 (char *) "self", NULL
4418 };
4419
4420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetSize",kwnames,&obj0)) goto fail;
4421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4422 if (SWIG_arg_fail(1)) SWIG_fail;
4423 {
4424 PyThreadState* __tstate = wxPyBeginAllowThreads();
4425 result = wxBitmap_GetSize(arg1);
4426
4427 wxPyEndAllowThreads(__tstate);
4428 if (PyErr_Occurred()) SWIG_fail;
4429 }
4430 {
4431 wxSize * resultptr;
4432 resultptr = new wxSize((wxSize &)(result));
4433 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
4434 }
4435 return resultobj;
4436 fail:
4437 return NULL;
4438 }
4439
4440
4441 static PyObject *_wrap_Bitmap_ConvertToImage(PyObject *, PyObject *args, PyObject *kwargs) {
4442 PyObject *resultobj;
4443 wxBitmap *arg1 = (wxBitmap *) 0 ;
4444 SwigValueWrapper<wxImage > result;
4445 PyObject * obj0 = 0 ;
4446 char *kwnames[] = {
4447 (char *) "self", NULL
4448 };
4449
4450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_ConvertToImage",kwnames,&obj0)) goto fail;
4451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4452 if (SWIG_arg_fail(1)) SWIG_fail;
4453 {
4454 PyThreadState* __tstate = wxPyBeginAllowThreads();
4455 result = ((wxBitmap const *)arg1)->ConvertToImage();
4456
4457 wxPyEndAllowThreads(__tstate);
4458 if (PyErr_Occurred()) SWIG_fail;
4459 }
4460 {
4461 wxImage * resultptr;
4462 resultptr = new wxImage((wxImage &)(result));
4463 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
4464 }
4465 return resultobj;
4466 fail:
4467 return NULL;
4468 }
4469
4470
4471 static PyObject *_wrap_Bitmap_GetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4472 PyObject *resultobj;
4473 wxBitmap *arg1 = (wxBitmap *) 0 ;
4474 wxMask *result;
4475 PyObject * obj0 = 0 ;
4476 char *kwnames[] = {
4477 (char *) "self", NULL
4478 };
4479
4480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetMask",kwnames,&obj0)) goto fail;
4481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4482 if (SWIG_arg_fail(1)) SWIG_fail;
4483 {
4484 PyThreadState* __tstate = wxPyBeginAllowThreads();
4485 result = (wxMask *)((wxBitmap const *)arg1)->GetMask();
4486
4487 wxPyEndAllowThreads(__tstate);
4488 if (PyErr_Occurred()) SWIG_fail;
4489 }
4490 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 0);
4491 return resultobj;
4492 fail:
4493 return NULL;
4494 }
4495
4496
4497 static PyObject *_wrap_Bitmap_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4498 PyObject *resultobj;
4499 wxBitmap *arg1 = (wxBitmap *) 0 ;
4500 wxMask *arg2 = (wxMask *) 0 ;
4501 PyObject * obj0 = 0 ;
4502 PyObject * obj1 = 0 ;
4503 char *kwnames[] = {
4504 (char *) "self",(char *) "mask", NULL
4505 };
4506
4507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMask",kwnames,&obj0,&obj1)) goto fail;
4508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4509 if (SWIG_arg_fail(1)) SWIG_fail;
4510 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMask, SWIG_POINTER_EXCEPTION | 0);
4511 if (SWIG_arg_fail(2)) SWIG_fail;
4512 {
4513 PyThreadState* __tstate = wxPyBeginAllowThreads();
4514 (arg1)->SetMask(arg2);
4515
4516 wxPyEndAllowThreads(__tstate);
4517 if (PyErr_Occurred()) SWIG_fail;
4518 }
4519 Py_INCREF(Py_None); resultobj = Py_None;
4520 return resultobj;
4521 fail:
4522 return NULL;
4523 }
4524
4525
4526 static PyObject *_wrap_Bitmap_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
4527 PyObject *resultobj;
4528 wxBitmap *arg1 = (wxBitmap *) 0 ;
4529 wxColour *arg2 = 0 ;
4530 wxColour temp2 ;
4531 PyObject * obj0 = 0 ;
4532 PyObject * obj1 = 0 ;
4533 char *kwnames[] = {
4534 (char *) "self",(char *) "colour", NULL
4535 };
4536
4537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMaskColour",kwnames,&obj0,&obj1)) goto fail;
4538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4539 if (SWIG_arg_fail(1)) SWIG_fail;
4540 {
4541 arg2 = &temp2;
4542 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4543 }
4544 {
4545 PyThreadState* __tstate = wxPyBeginAllowThreads();
4546 wxBitmap_SetMaskColour(arg1,(wxColour const &)*arg2);
4547
4548 wxPyEndAllowThreads(__tstate);
4549 if (PyErr_Occurred()) SWIG_fail;
4550 }
4551 Py_INCREF(Py_None); resultobj = Py_None;
4552 return resultobj;
4553 fail:
4554 return NULL;
4555 }
4556
4557
4558 static PyObject *_wrap_Bitmap_GetSubBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4559 PyObject *resultobj;
4560 wxBitmap *arg1 = (wxBitmap *) 0 ;
4561 wxRect *arg2 = 0 ;
4562 SwigValueWrapper<wxBitmap > result;
4563 wxRect temp2 ;
4564 PyObject * obj0 = 0 ;
4565 PyObject * obj1 = 0 ;
4566 char *kwnames[] = {
4567 (char *) "self",(char *) "rect", NULL
4568 };
4569
4570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_GetSubBitmap",kwnames,&obj0,&obj1)) goto fail;
4571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4572 if (SWIG_arg_fail(1)) SWIG_fail;
4573 {
4574 arg2 = &temp2;
4575 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4576 }
4577 {
4578 PyThreadState* __tstate = wxPyBeginAllowThreads();
4579 result = ((wxBitmap const *)arg1)->GetSubBitmap((wxRect const &)*arg2);
4580
4581 wxPyEndAllowThreads(__tstate);
4582 if (PyErr_Occurred()) SWIG_fail;
4583 }
4584 {
4585 wxBitmap * resultptr;
4586 resultptr = new wxBitmap((wxBitmap &)(result));
4587 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
4588 }
4589 return resultobj;
4590 fail:
4591 return NULL;
4592 }
4593
4594
4595 static PyObject *_wrap_Bitmap_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
4596 PyObject *resultobj;
4597 wxBitmap *arg1 = (wxBitmap *) 0 ;
4598 wxString *arg2 = 0 ;
4599 wxBitmapType arg3 ;
4600 wxPalette *arg4 = (wxPalette *) NULL ;
4601 bool result;
4602 bool temp2 = false ;
4603 PyObject * obj0 = 0 ;
4604 PyObject * obj1 = 0 ;
4605 PyObject * obj2 = 0 ;
4606 PyObject * obj3 = 0 ;
4607 char *kwnames[] = {
4608 (char *) "self",(char *) "name",(char *) "type",(char *) "palette", NULL
4609 };
4610
4611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Bitmap_SaveFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4613 if (SWIG_arg_fail(1)) SWIG_fail;
4614 {
4615 arg2 = wxString_in_helper(obj1);
4616 if (arg2 == NULL) SWIG_fail;
4617 temp2 = true;
4618 }
4619 {
4620 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4621 if (SWIG_arg_fail(3)) SWIG_fail;
4622 }
4623 if (obj3) {
4624 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
4625 if (SWIG_arg_fail(4)) SWIG_fail;
4626 }
4627 {
4628 PyThreadState* __tstate = wxPyBeginAllowThreads();
4629 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxBitmapType )arg3,arg4);
4630
4631 wxPyEndAllowThreads(__tstate);
4632 if (PyErr_Occurred()) SWIG_fail;
4633 }
4634 {
4635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4636 }
4637 {
4638 if (temp2)
4639 delete arg2;
4640 }
4641 return resultobj;
4642 fail:
4643 {
4644 if (temp2)
4645 delete arg2;
4646 }
4647 return NULL;
4648 }
4649
4650
4651 static PyObject *_wrap_Bitmap_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
4652 PyObject *resultobj;
4653 wxBitmap *arg1 = (wxBitmap *) 0 ;
4654 wxString *arg2 = 0 ;
4655 wxBitmapType arg3 ;
4656 bool result;
4657 bool temp2 = false ;
4658 PyObject * obj0 = 0 ;
4659 PyObject * obj1 = 0 ;
4660 PyObject * obj2 = 0 ;
4661 char *kwnames[] = {
4662 (char *) "self",(char *) "name",(char *) "type", NULL
4663 };
4664
4665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Bitmap_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
4666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4667 if (SWIG_arg_fail(1)) SWIG_fail;
4668 {
4669 arg2 = wxString_in_helper(obj1);
4670 if (arg2 == NULL) SWIG_fail;
4671 temp2 = true;
4672 }
4673 {
4674 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4675 if (SWIG_arg_fail(3)) SWIG_fail;
4676 }
4677 {
4678 PyThreadState* __tstate = wxPyBeginAllowThreads();
4679 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
4680
4681 wxPyEndAllowThreads(__tstate);
4682 if (PyErr_Occurred()) SWIG_fail;
4683 }
4684 {
4685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4686 }
4687 {
4688 if (temp2)
4689 delete arg2;
4690 }
4691 return resultobj;
4692 fail:
4693 {
4694 if (temp2)
4695 delete arg2;
4696 }
4697 return NULL;
4698 }
4699
4700
4701 static PyObject *_wrap_Bitmap_GetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
4702 PyObject *resultobj;
4703 wxBitmap *arg1 = (wxBitmap *) 0 ;
4704 wxPalette *result;
4705 PyObject * obj0 = 0 ;
4706 char *kwnames[] = {
4707 (char *) "self", NULL
4708 };
4709
4710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetPalette",kwnames,&obj0)) goto fail;
4711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4712 if (SWIG_arg_fail(1)) SWIG_fail;
4713 {
4714 PyThreadState* __tstate = wxPyBeginAllowThreads();
4715 result = (wxPalette *)((wxBitmap const *)arg1)->GetPalette();
4716
4717 wxPyEndAllowThreads(__tstate);
4718 if (PyErr_Occurred()) SWIG_fail;
4719 }
4720 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 0);
4721 return resultobj;
4722 fail:
4723 return NULL;
4724 }
4725
4726
4727 static PyObject *_wrap_Bitmap_SetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
4728 PyObject *resultobj;
4729 wxBitmap *arg1 = (wxBitmap *) 0 ;
4730 wxPalette *arg2 = 0 ;
4731 PyObject * obj0 = 0 ;
4732 PyObject * obj1 = 0 ;
4733 char *kwnames[] = {
4734 (char *) "self",(char *) "palette", NULL
4735 };
4736
4737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetPalette",kwnames,&obj0,&obj1)) goto fail;
4738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4739 if (SWIG_arg_fail(1)) SWIG_fail;
4740 {
4741 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
4742 if (SWIG_arg_fail(2)) SWIG_fail;
4743 if (arg2 == NULL) {
4744 SWIG_null_ref("wxPalette");
4745 }
4746 if (SWIG_arg_fail(2)) SWIG_fail;
4747 }
4748 {
4749 PyThreadState* __tstate = wxPyBeginAllowThreads();
4750 (arg1)->SetPalette((wxPalette const &)*arg2);
4751
4752 wxPyEndAllowThreads(__tstate);
4753 if (PyErr_Occurred()) SWIG_fail;
4754 }
4755 Py_INCREF(Py_None); resultobj = Py_None;
4756 return resultobj;
4757 fail:
4758 return NULL;
4759 }
4760
4761
4762 static PyObject *_wrap_Bitmap_CopyFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4763 PyObject *resultobj;
4764 wxBitmap *arg1 = (wxBitmap *) 0 ;
4765 wxIcon *arg2 = 0 ;
4766 bool result;
4767 PyObject * obj0 = 0 ;
4768 PyObject * obj1 = 0 ;
4769 char *kwnames[] = {
4770 (char *) "self",(char *) "icon", NULL
4771 };
4772
4773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromIcon",kwnames,&obj0,&obj1)) goto fail;
4774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4775 if (SWIG_arg_fail(1)) SWIG_fail;
4776 {
4777 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4778 if (SWIG_arg_fail(2)) SWIG_fail;
4779 if (arg2 == NULL) {
4780 SWIG_null_ref("wxIcon");
4781 }
4782 if (SWIG_arg_fail(2)) SWIG_fail;
4783 }
4784 {
4785 PyThreadState* __tstate = wxPyBeginAllowThreads();
4786 result = (bool)(arg1)->CopyFromIcon((wxIcon const &)*arg2);
4787
4788 wxPyEndAllowThreads(__tstate);
4789 if (PyErr_Occurred()) SWIG_fail;
4790 }
4791 {
4792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4793 }
4794 return resultobj;
4795 fail:
4796 return NULL;
4797 }
4798
4799
4800 static PyObject *_wrap_Bitmap_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4801 PyObject *resultobj;
4802 wxBitmap *arg1 = (wxBitmap *) 0 ;
4803 int arg2 ;
4804 PyObject * obj0 = 0 ;
4805 PyObject * obj1 = 0 ;
4806 char *kwnames[] = {
4807 (char *) "self",(char *) "height", NULL
4808 };
4809
4810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHeight",kwnames,&obj0,&obj1)) goto fail;
4811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4812 if (SWIG_arg_fail(1)) SWIG_fail;
4813 {
4814 arg2 = (int)(SWIG_As_int(obj1));
4815 if (SWIG_arg_fail(2)) SWIG_fail;
4816 }
4817 {
4818 PyThreadState* __tstate = wxPyBeginAllowThreads();
4819 (arg1)->SetHeight(arg2);
4820
4821 wxPyEndAllowThreads(__tstate);
4822 if (PyErr_Occurred()) SWIG_fail;
4823 }
4824 Py_INCREF(Py_None); resultobj = Py_None;
4825 return resultobj;
4826 fail:
4827 return NULL;
4828 }
4829
4830
4831 static PyObject *_wrap_Bitmap_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4832 PyObject *resultobj;
4833 wxBitmap *arg1 = (wxBitmap *) 0 ;
4834 int arg2 ;
4835 PyObject * obj0 = 0 ;
4836 PyObject * obj1 = 0 ;
4837 char *kwnames[] = {
4838 (char *) "self",(char *) "width", NULL
4839 };
4840
4841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetWidth",kwnames,&obj0,&obj1)) goto fail;
4842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4843 if (SWIG_arg_fail(1)) SWIG_fail;
4844 {
4845 arg2 = (int)(SWIG_As_int(obj1));
4846 if (SWIG_arg_fail(2)) SWIG_fail;
4847 }
4848 {
4849 PyThreadState* __tstate = wxPyBeginAllowThreads();
4850 (arg1)->SetWidth(arg2);
4851
4852 wxPyEndAllowThreads(__tstate);
4853 if (PyErr_Occurred()) SWIG_fail;
4854 }
4855 Py_INCREF(Py_None); resultobj = Py_None;
4856 return resultobj;
4857 fail:
4858 return NULL;
4859 }
4860
4861
4862 static PyObject *_wrap_Bitmap_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4863 PyObject *resultobj;
4864 wxBitmap *arg1 = (wxBitmap *) 0 ;
4865 int arg2 ;
4866 PyObject * obj0 = 0 ;
4867 PyObject * obj1 = 0 ;
4868 char *kwnames[] = {
4869 (char *) "self",(char *) "depth", NULL
4870 };
4871
4872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetDepth",kwnames,&obj0,&obj1)) goto fail;
4873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4874 if (SWIG_arg_fail(1)) SWIG_fail;
4875 {
4876 arg2 = (int)(SWIG_As_int(obj1));
4877 if (SWIG_arg_fail(2)) SWIG_fail;
4878 }
4879 {
4880 PyThreadState* __tstate = wxPyBeginAllowThreads();
4881 (arg1)->SetDepth(arg2);
4882
4883 wxPyEndAllowThreads(__tstate);
4884 if (PyErr_Occurred()) SWIG_fail;
4885 }
4886 Py_INCREF(Py_None); resultobj = Py_None;
4887 return resultobj;
4888 fail:
4889 return NULL;
4890 }
4891
4892
4893 static PyObject *_wrap_Bitmap_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4894 PyObject *resultobj;
4895 wxBitmap *arg1 = (wxBitmap *) 0 ;
4896 wxSize *arg2 = 0 ;
4897 wxSize temp2 ;
4898 PyObject * obj0 = 0 ;
4899 PyObject * obj1 = 0 ;
4900 char *kwnames[] = {
4901 (char *) "self",(char *) "size", NULL
4902 };
4903
4904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetSize",kwnames,&obj0,&obj1)) goto fail;
4905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4906 if (SWIG_arg_fail(1)) SWIG_fail;
4907 {
4908 arg2 = &temp2;
4909 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4910 }
4911 {
4912 PyThreadState* __tstate = wxPyBeginAllowThreads();
4913 wxBitmap_SetSize(arg1,(wxSize const &)*arg2);
4914
4915 wxPyEndAllowThreads(__tstate);
4916 if (PyErr_Occurred()) SWIG_fail;
4917 }
4918 Py_INCREF(Py_None); resultobj = Py_None;
4919 return resultobj;
4920 fail:
4921 return NULL;
4922 }
4923
4924
4925 static PyObject *_wrap_Bitmap_CopyFromCursor(PyObject *, PyObject *args, PyObject *kwargs) {
4926 PyObject *resultobj;
4927 wxBitmap *arg1 = (wxBitmap *) 0 ;
4928 wxCursor *arg2 = 0 ;
4929 bool result;
4930 PyObject * obj0 = 0 ;
4931 PyObject * obj1 = 0 ;
4932 char *kwnames[] = {
4933 (char *) "self",(char *) "cursor", NULL
4934 };
4935
4936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromCursor",kwnames,&obj0,&obj1)) goto fail;
4937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4938 if (SWIG_arg_fail(1)) SWIG_fail;
4939 {
4940 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
4941 if (SWIG_arg_fail(2)) SWIG_fail;
4942 if (arg2 == NULL) {
4943 SWIG_null_ref("wxCursor");
4944 }
4945 if (SWIG_arg_fail(2)) SWIG_fail;
4946 }
4947 {
4948 PyThreadState* __tstate = wxPyBeginAllowThreads();
4949 result = (bool)(arg1)->CopyFromCursor((wxCursor const &)*arg2);
4950
4951 wxPyEndAllowThreads(__tstate);
4952 if (PyErr_Occurred()) SWIG_fail;
4953 }
4954 {
4955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4956 }
4957 return resultobj;
4958 fail:
4959 return NULL;
4960 }
4961
4962
4963 static PyObject *_wrap_Bitmap_GetQuality(PyObject *, PyObject *args, PyObject *kwargs) {
4964 PyObject *resultobj;
4965 wxBitmap *arg1 = (wxBitmap *) 0 ;
4966 int result;
4967 PyObject * obj0 = 0 ;
4968 char *kwnames[] = {
4969 (char *) "self", NULL
4970 };
4971
4972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetQuality",kwnames,&obj0)) goto fail;
4973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4974 if (SWIG_arg_fail(1)) SWIG_fail;
4975 {
4976 PyThreadState* __tstate = wxPyBeginAllowThreads();
4977 result = (int)(arg1)->GetQuality();
4978
4979 wxPyEndAllowThreads(__tstate);
4980 if (PyErr_Occurred()) SWIG_fail;
4981 }
4982 {
4983 resultobj = SWIG_From_int((int)(result));
4984 }
4985 return resultobj;
4986 fail:
4987 return NULL;
4988 }
4989
4990
4991 static PyObject *_wrap_Bitmap_SetQuality(PyObject *, PyObject *args, PyObject *kwargs) {
4992 PyObject *resultobj;
4993 wxBitmap *arg1 = (wxBitmap *) 0 ;
4994 int arg2 ;
4995 PyObject * obj0 = 0 ;
4996 PyObject * obj1 = 0 ;
4997 char *kwnames[] = {
4998 (char *) "self",(char *) "q", NULL
4999 };
5000
5001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetQuality",kwnames,&obj0,&obj1)) goto fail;
5002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5003 if (SWIG_arg_fail(1)) SWIG_fail;
5004 {
5005 arg2 = (int)(SWIG_As_int(obj1));
5006 if (SWIG_arg_fail(2)) SWIG_fail;
5007 }
5008 {
5009 PyThreadState* __tstate = wxPyBeginAllowThreads();
5010 (arg1)->SetQuality(arg2);
5011
5012 wxPyEndAllowThreads(__tstate);
5013 if (PyErr_Occurred()) SWIG_fail;
5014 }
5015 Py_INCREF(Py_None); resultobj = Py_None;
5016 return resultobj;
5017 fail:
5018 return NULL;
5019 }
5020
5021
5022 static PyObject *_wrap_Bitmap___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5023 PyObject *resultobj;
5024 wxBitmap *arg1 = (wxBitmap *) 0 ;
5025 wxBitmap *arg2 = (wxBitmap *) 0 ;
5026 bool result;
5027 PyObject * obj0 = 0 ;
5028 PyObject * obj1 = 0 ;
5029 char *kwnames[] = {
5030 (char *) "self",(char *) "other", NULL
5031 };
5032
5033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___eq__",kwnames,&obj0,&obj1)) goto fail;
5034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5035 if (SWIG_arg_fail(1)) SWIG_fail;
5036 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5037 if (SWIG_arg_fail(2)) SWIG_fail;
5038 {
5039 PyThreadState* __tstate = wxPyBeginAllowThreads();
5040 result = (bool)wxBitmap___eq__(arg1,(wxBitmap const *)arg2);
5041
5042 wxPyEndAllowThreads(__tstate);
5043 if (PyErr_Occurred()) SWIG_fail;
5044 }
5045 {
5046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5047 }
5048 return resultobj;
5049 fail:
5050 return NULL;
5051 }
5052
5053
5054 static PyObject *_wrap_Bitmap___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
5055 PyObject *resultobj;
5056 wxBitmap *arg1 = (wxBitmap *) 0 ;
5057 wxBitmap *arg2 = (wxBitmap *) 0 ;
5058 bool result;
5059 PyObject * obj0 = 0 ;
5060 PyObject * obj1 = 0 ;
5061 char *kwnames[] = {
5062 (char *) "self",(char *) "other", NULL
5063 };
5064
5065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___ne__",kwnames,&obj0,&obj1)) goto fail;
5066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5067 if (SWIG_arg_fail(1)) SWIG_fail;
5068 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5069 if (SWIG_arg_fail(2)) SWIG_fail;
5070 {
5071 PyThreadState* __tstate = wxPyBeginAllowThreads();
5072 result = (bool)wxBitmap___ne__(arg1,(wxBitmap const *)arg2);
5073
5074 wxPyEndAllowThreads(__tstate);
5075 if (PyErr_Occurred()) SWIG_fail;
5076 }
5077 {
5078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5079 }
5080 return resultobj;
5081 fail:
5082 return NULL;
5083 }
5084
5085
5086 static PyObject * Bitmap_swigregister(PyObject *, PyObject *args) {
5087 PyObject *obj;
5088 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5089 SWIG_TypeClientData(SWIGTYPE_p_wxBitmap, obj);
5090 Py_INCREF(obj);
5091 return Py_BuildValue((char *)"");
5092 }
5093 static PyObject *_wrap_new_Mask(PyObject *, PyObject *args, PyObject *kwargs) {
5094 PyObject *resultobj;
5095 wxBitmap *arg1 = 0 ;
5096 wxColour const &arg2_defvalue = wxNullColour ;
5097 wxColour *arg2 = (wxColour *) &arg2_defvalue ;
5098 wxMask *result;
5099 wxColour temp2 ;
5100 PyObject * obj0 = 0 ;
5101 PyObject * obj1 = 0 ;
5102 char *kwnames[] = {
5103 (char *) "bitmap",(char *) "colour", NULL
5104 };
5105
5106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Mask",kwnames,&obj0,&obj1)) goto fail;
5107 {
5108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5109 if (SWIG_arg_fail(1)) SWIG_fail;
5110 if (arg1 == NULL) {
5111 SWIG_null_ref("wxBitmap");
5112 }
5113 if (SWIG_arg_fail(1)) SWIG_fail;
5114 }
5115 if (obj1) {
5116 {
5117 arg2 = &temp2;
5118 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5119 }
5120 }
5121 {
5122 if (!wxPyCheckForApp()) SWIG_fail;
5123 PyThreadState* __tstate = wxPyBeginAllowThreads();
5124 result = (wxMask *)new_wxMask((wxBitmap const &)*arg1,(wxColour const &)*arg2);
5125
5126 wxPyEndAllowThreads(__tstate);
5127 if (PyErr_Occurred()) SWIG_fail;
5128 }
5129 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 1);
5130 return resultobj;
5131 fail:
5132 return NULL;
5133 }
5134
5135
5136 static PyObject * Mask_swigregister(PyObject *, PyObject *args) {
5137 PyObject *obj;
5138 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5139 SWIG_TypeClientData(SWIGTYPE_p_wxMask, obj);
5140 Py_INCREF(obj);
5141 return Py_BuildValue((char *)"");
5142 }
5143 static PyObject *_wrap_new_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
5144 PyObject *resultobj;
5145 wxString *arg1 = 0 ;
5146 wxBitmapType arg2 ;
5147 int arg3 = (int) -1 ;
5148 int arg4 = (int) -1 ;
5149 wxIcon *result;
5150 bool temp1 = false ;
5151 PyObject * obj0 = 0 ;
5152 PyObject * obj1 = 0 ;
5153 PyObject * obj2 = 0 ;
5154 PyObject * obj3 = 0 ;
5155 char *kwnames[] = {
5156 (char *) "name",(char *) "type",(char *) "desiredWidth",(char *) "desiredHeight", NULL
5157 };
5158
5159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Icon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5160 {
5161 arg1 = wxString_in_helper(obj0);
5162 if (arg1 == NULL) SWIG_fail;
5163 temp1 = true;
5164 }
5165 {
5166 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
5167 if (SWIG_arg_fail(2)) SWIG_fail;
5168 }
5169 if (obj2) {
5170 {
5171 arg3 = (int)(SWIG_As_int(obj2));
5172 if (SWIG_arg_fail(3)) SWIG_fail;
5173 }
5174 }
5175 if (obj3) {
5176 {
5177 arg4 = (int)(SWIG_As_int(obj3));
5178 if (SWIG_arg_fail(4)) SWIG_fail;
5179 }
5180 }
5181 {
5182 if (!wxPyCheckForApp()) SWIG_fail;
5183 PyThreadState* __tstate = wxPyBeginAllowThreads();
5184 result = (wxIcon *)new wxIcon((wxString const &)*arg1,(wxBitmapType )arg2,arg3,arg4);
5185
5186 wxPyEndAllowThreads(__tstate);
5187 if (PyErr_Occurred()) SWIG_fail;
5188 }
5189 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5190 {
5191 if (temp1)
5192 delete arg1;
5193 }
5194 return resultobj;
5195 fail:
5196 {
5197 if (temp1)
5198 delete arg1;
5199 }
5200 return NULL;
5201 }
5202
5203
5204 static PyObject *_wrap_delete_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
5205 PyObject *resultobj;
5206 wxIcon *arg1 = (wxIcon *) 0 ;
5207 PyObject * obj0 = 0 ;
5208 char *kwnames[] = {
5209 (char *) "self", NULL
5210 };
5211
5212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Icon",kwnames,&obj0)) goto fail;
5213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5214 if (SWIG_arg_fail(1)) SWIG_fail;
5215 {
5216 PyThreadState* __tstate = wxPyBeginAllowThreads();
5217 delete arg1;
5218
5219 wxPyEndAllowThreads(__tstate);
5220 if (PyErr_Occurred()) SWIG_fail;
5221 }
5222 Py_INCREF(Py_None); resultobj = Py_None;
5223 return resultobj;
5224 fail:
5225 return NULL;
5226 }
5227
5228
5229 static PyObject *_wrap_new_EmptyIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5230 PyObject *resultobj;
5231 wxIcon *result;
5232 char *kwnames[] = {
5233 NULL
5234 };
5235
5236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EmptyIcon",kwnames)) goto fail;
5237 {
5238 if (!wxPyCheckForApp()) SWIG_fail;
5239 PyThreadState* __tstate = wxPyBeginAllowThreads();
5240 result = (wxIcon *)new wxIcon();
5241
5242 wxPyEndAllowThreads(__tstate);
5243 if (PyErr_Occurred()) SWIG_fail;
5244 }
5245 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5246 return resultobj;
5247 fail:
5248 return NULL;
5249 }
5250
5251
5252 static PyObject *_wrap_new_IconFromLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5253 PyObject *resultobj;
5254 wxIconLocation *arg1 = 0 ;
5255 wxIcon *result;
5256 PyObject * obj0 = 0 ;
5257 char *kwnames[] = {
5258 (char *) "loc", NULL
5259 };
5260
5261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromLocation",kwnames,&obj0)) goto fail;
5262 {
5263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5264 if (SWIG_arg_fail(1)) SWIG_fail;
5265 if (arg1 == NULL) {
5266 SWIG_null_ref("wxIconLocation");
5267 }
5268 if (SWIG_arg_fail(1)) SWIG_fail;
5269 }
5270 {
5271 if (!wxPyCheckForApp()) SWIG_fail;
5272 PyThreadState* __tstate = wxPyBeginAllowThreads();
5273 result = (wxIcon *)new wxIcon((wxIconLocation const &)*arg1);
5274
5275 wxPyEndAllowThreads(__tstate);
5276 if (PyErr_Occurred()) SWIG_fail;
5277 }
5278 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5279 return resultobj;
5280 fail:
5281 return NULL;
5282 }
5283
5284
5285 static PyObject *_wrap_new_IconFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5286 PyObject *resultobj;
5287 wxBitmap *arg1 = 0 ;
5288 wxIcon *result;
5289 PyObject * obj0 = 0 ;
5290 char *kwnames[] = {
5291 (char *) "bmp", NULL
5292 };
5293
5294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromBitmap",kwnames,&obj0)) goto fail;
5295 {
5296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5297 if (SWIG_arg_fail(1)) SWIG_fail;
5298 if (arg1 == NULL) {
5299 SWIG_null_ref("wxBitmap");
5300 }
5301 if (SWIG_arg_fail(1)) SWIG_fail;
5302 }
5303 {
5304 if (!wxPyCheckForApp()) SWIG_fail;
5305 PyThreadState* __tstate = wxPyBeginAllowThreads();
5306 result = (wxIcon *)new_wxIcon((wxBitmap const &)*arg1);
5307
5308 wxPyEndAllowThreads(__tstate);
5309 if (PyErr_Occurred()) SWIG_fail;
5310 }
5311 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5312 return resultobj;
5313 fail:
5314 return NULL;
5315 }
5316
5317
5318 static PyObject *_wrap_new_IconFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
5319 PyObject *resultobj;
5320 PyObject *arg1 = (PyObject *) 0 ;
5321 wxIcon *result;
5322 PyObject * obj0 = 0 ;
5323 char *kwnames[] = {
5324 (char *) "listOfStrings", NULL
5325 };
5326
5327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromXPMData",kwnames,&obj0)) goto fail;
5328 arg1 = obj0;
5329 {
5330 if (!wxPyCheckForApp()) SWIG_fail;
5331 PyThreadState* __tstate = wxPyBeginAllowThreads();
5332 result = (wxIcon *)new_wxIcon(arg1);
5333
5334 wxPyEndAllowThreads(__tstate);
5335 if (PyErr_Occurred()) SWIG_fail;
5336 }
5337 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5338 return resultobj;
5339 fail:
5340 return NULL;
5341 }
5342
5343
5344 static PyObject *_wrap_Icon_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
5345 PyObject *resultobj;
5346 wxIcon *arg1 = (wxIcon *) 0 ;
5347 wxString *arg2 = 0 ;
5348 wxBitmapType arg3 ;
5349 bool result;
5350 bool temp2 = false ;
5351 PyObject * obj0 = 0 ;
5352 PyObject * obj1 = 0 ;
5353 PyObject * obj2 = 0 ;
5354 char *kwnames[] = {
5355 (char *) "self",(char *) "name",(char *) "type", NULL
5356 };
5357
5358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Icon_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
5359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5360 if (SWIG_arg_fail(1)) SWIG_fail;
5361 {
5362 arg2 = wxString_in_helper(obj1);
5363 if (arg2 == NULL) SWIG_fail;
5364 temp2 = true;
5365 }
5366 {
5367 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
5368 if (SWIG_arg_fail(3)) SWIG_fail;
5369 }
5370 {
5371 PyThreadState* __tstate = wxPyBeginAllowThreads();
5372 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
5373
5374 wxPyEndAllowThreads(__tstate);
5375 if (PyErr_Occurred()) SWIG_fail;
5376 }
5377 {
5378 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5379 }
5380 {
5381 if (temp2)
5382 delete arg2;
5383 }
5384 return resultobj;
5385 fail:
5386 {
5387 if (temp2)
5388 delete arg2;
5389 }
5390 return NULL;
5391 }
5392
5393
5394 static PyObject *_wrap_Icon_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
5395 PyObject *resultobj;
5396 wxIcon *arg1 = (wxIcon *) 0 ;
5397 long result;
5398 PyObject * obj0 = 0 ;
5399 char *kwnames[] = {
5400 (char *) "self", NULL
5401 };
5402
5403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetHandle",kwnames,&obj0)) goto fail;
5404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5405 if (SWIG_arg_fail(1)) SWIG_fail;
5406 {
5407 PyThreadState* __tstate = wxPyBeginAllowThreads();
5408 result = (long)(arg1)->GetHandle();
5409
5410 wxPyEndAllowThreads(__tstate);
5411 if (PyErr_Occurred()) SWIG_fail;
5412 }
5413 {
5414 resultobj = SWIG_From_long((long)(result));
5415 }
5416 return resultobj;
5417 fail:
5418 return NULL;
5419 }
5420
5421
5422 static PyObject *_wrap_Icon_SetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
5423 PyObject *resultobj;
5424 wxIcon *arg1 = (wxIcon *) 0 ;
5425 long arg2 ;
5426 PyObject * obj0 = 0 ;
5427 PyObject * obj1 = 0 ;
5428 char *kwnames[] = {
5429 (char *) "self",(char *) "handle", NULL
5430 };
5431
5432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHandle",kwnames,&obj0,&obj1)) goto fail;
5433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5434 if (SWIG_arg_fail(1)) SWIG_fail;
5435 {
5436 arg2 = (long)(SWIG_As_long(obj1));
5437 if (SWIG_arg_fail(2)) SWIG_fail;
5438 }
5439 {
5440 PyThreadState* __tstate = wxPyBeginAllowThreads();
5441 wxIcon_SetHandle(arg1,arg2);
5442
5443 wxPyEndAllowThreads(__tstate);
5444 if (PyErr_Occurred()) SWIG_fail;
5445 }
5446 Py_INCREF(Py_None); resultobj = Py_None;
5447 return resultobj;
5448 fail:
5449 return NULL;
5450 }
5451
5452
5453 static PyObject *_wrap_Icon_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
5454 PyObject *resultobj;
5455 wxIcon *arg1 = (wxIcon *) 0 ;
5456 bool result;
5457 PyObject * obj0 = 0 ;
5458 char *kwnames[] = {
5459 (char *) "self", NULL
5460 };
5461
5462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_Ok",kwnames,&obj0)) goto fail;
5463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5464 if (SWIG_arg_fail(1)) SWIG_fail;
5465 {
5466 PyThreadState* __tstate = wxPyBeginAllowThreads();
5467 result = (bool)(arg1)->Ok();
5468
5469 wxPyEndAllowThreads(__tstate);
5470 if (PyErr_Occurred()) SWIG_fail;
5471 }
5472 {
5473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5474 }
5475 return resultobj;
5476 fail:
5477 return NULL;
5478 }
5479
5480
5481 static PyObject *_wrap_Icon_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5482 PyObject *resultobj;
5483 wxIcon *arg1 = (wxIcon *) 0 ;
5484 int result;
5485 PyObject * obj0 = 0 ;
5486 char *kwnames[] = {
5487 (char *) "self", NULL
5488 };
5489
5490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetWidth",kwnames,&obj0)) goto fail;
5491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5492 if (SWIG_arg_fail(1)) SWIG_fail;
5493 {
5494 PyThreadState* __tstate = wxPyBeginAllowThreads();
5495 result = (int)(arg1)->GetWidth();
5496
5497 wxPyEndAllowThreads(__tstate);
5498 if (PyErr_Occurred()) SWIG_fail;
5499 }
5500 {
5501 resultobj = SWIG_From_int((int)(result));
5502 }
5503 return resultobj;
5504 fail:
5505 return NULL;
5506 }
5507
5508
5509 static PyObject *_wrap_Icon_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5510 PyObject *resultobj;
5511 wxIcon *arg1 = (wxIcon *) 0 ;
5512 int result;
5513 PyObject * obj0 = 0 ;
5514 char *kwnames[] = {
5515 (char *) "self", NULL
5516 };
5517
5518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetHeight",kwnames,&obj0)) goto fail;
5519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5520 if (SWIG_arg_fail(1)) SWIG_fail;
5521 {
5522 PyThreadState* __tstate = wxPyBeginAllowThreads();
5523 result = (int)(arg1)->GetHeight();
5524
5525 wxPyEndAllowThreads(__tstate);
5526 if (PyErr_Occurred()) SWIG_fail;
5527 }
5528 {
5529 resultobj = SWIG_From_int((int)(result));
5530 }
5531 return resultobj;
5532 fail:
5533 return NULL;
5534 }
5535
5536
5537 static PyObject *_wrap_Icon_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5538 PyObject *resultobj;
5539 wxIcon *arg1 = (wxIcon *) 0 ;
5540 int result;
5541 PyObject * obj0 = 0 ;
5542 char *kwnames[] = {
5543 (char *) "self", NULL
5544 };
5545
5546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetDepth",kwnames,&obj0)) goto fail;
5547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5548 if (SWIG_arg_fail(1)) SWIG_fail;
5549 {
5550 PyThreadState* __tstate = wxPyBeginAllowThreads();
5551 result = (int)(arg1)->GetDepth();
5552
5553 wxPyEndAllowThreads(__tstate);
5554 if (PyErr_Occurred()) SWIG_fail;
5555 }
5556 {
5557 resultobj = SWIG_From_int((int)(result));
5558 }
5559 return resultobj;
5560 fail:
5561 return NULL;
5562 }
5563
5564
5565 static PyObject *_wrap_Icon_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5566 PyObject *resultobj;
5567 wxIcon *arg1 = (wxIcon *) 0 ;
5568 int arg2 ;
5569 PyObject * obj0 = 0 ;
5570 PyObject * obj1 = 0 ;
5571 char *kwnames[] = {
5572 (char *) "self",(char *) "w", NULL
5573 };
5574
5575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5577 if (SWIG_arg_fail(1)) SWIG_fail;
5578 {
5579 arg2 = (int)(SWIG_As_int(obj1));
5580 if (SWIG_arg_fail(2)) SWIG_fail;
5581 }
5582 {
5583 PyThreadState* __tstate = wxPyBeginAllowThreads();
5584 (arg1)->SetWidth(arg2);
5585
5586 wxPyEndAllowThreads(__tstate);
5587 if (PyErr_Occurred()) SWIG_fail;
5588 }
5589 Py_INCREF(Py_None); resultobj = Py_None;
5590 return resultobj;
5591 fail:
5592 return NULL;
5593 }
5594
5595
5596 static PyObject *_wrap_Icon_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5597 PyObject *resultobj;
5598 wxIcon *arg1 = (wxIcon *) 0 ;
5599 int arg2 ;
5600 PyObject * obj0 = 0 ;
5601 PyObject * obj1 = 0 ;
5602 char *kwnames[] = {
5603 (char *) "self",(char *) "h", NULL
5604 };
5605
5606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5608 if (SWIG_arg_fail(1)) SWIG_fail;
5609 {
5610 arg2 = (int)(SWIG_As_int(obj1));
5611 if (SWIG_arg_fail(2)) SWIG_fail;
5612 }
5613 {
5614 PyThreadState* __tstate = wxPyBeginAllowThreads();
5615 (arg1)->SetHeight(arg2);
5616
5617 wxPyEndAllowThreads(__tstate);
5618 if (PyErr_Occurred()) SWIG_fail;
5619 }
5620 Py_INCREF(Py_None); resultobj = Py_None;
5621 return resultobj;
5622 fail:
5623 return NULL;
5624 }
5625
5626
5627 static PyObject *_wrap_Icon_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5628 PyObject *resultobj;
5629 wxIcon *arg1 = (wxIcon *) 0 ;
5630 int arg2 ;
5631 PyObject * obj0 = 0 ;
5632 PyObject * obj1 = 0 ;
5633 char *kwnames[] = {
5634 (char *) "self",(char *) "d", NULL
5635 };
5636
5637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetDepth",kwnames,&obj0,&obj1)) goto fail;
5638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5639 if (SWIG_arg_fail(1)) SWIG_fail;
5640 {
5641 arg2 = (int)(SWIG_As_int(obj1));
5642 if (SWIG_arg_fail(2)) SWIG_fail;
5643 }
5644 {
5645 PyThreadState* __tstate = wxPyBeginAllowThreads();
5646 (arg1)->SetDepth(arg2);
5647
5648 wxPyEndAllowThreads(__tstate);
5649 if (PyErr_Occurred()) SWIG_fail;
5650 }
5651 Py_INCREF(Py_None); resultobj = Py_None;
5652 return resultobj;
5653 fail:
5654 return NULL;
5655 }
5656
5657
5658 static PyObject *_wrap_Icon_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5659 PyObject *resultobj;
5660 wxIcon *arg1 = (wxIcon *) 0 ;
5661 wxSize *arg2 = 0 ;
5662 wxSize temp2 ;
5663 PyObject * obj0 = 0 ;
5664 PyObject * obj1 = 0 ;
5665 char *kwnames[] = {
5666 (char *) "self",(char *) "size", NULL
5667 };
5668
5669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetSize",kwnames,&obj0,&obj1)) goto fail;
5670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5671 if (SWIG_arg_fail(1)) SWIG_fail;
5672 {
5673 arg2 = &temp2;
5674 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5675 }
5676 {
5677 PyThreadState* __tstate = wxPyBeginAllowThreads();
5678 (arg1)->SetSize((wxSize const &)*arg2);
5679
5680 wxPyEndAllowThreads(__tstate);
5681 if (PyErr_Occurred()) SWIG_fail;
5682 }
5683 Py_INCREF(Py_None); resultobj = Py_None;
5684 return resultobj;
5685 fail:
5686 return NULL;
5687 }
5688
5689
5690 static PyObject *_wrap_Icon_CopyFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5691 PyObject *resultobj;
5692 wxIcon *arg1 = (wxIcon *) 0 ;
5693 wxBitmap *arg2 = 0 ;
5694 PyObject * obj0 = 0 ;
5695 PyObject * obj1 = 0 ;
5696 char *kwnames[] = {
5697 (char *) "self",(char *) "bmp", NULL
5698 };
5699
5700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_CopyFromBitmap",kwnames,&obj0,&obj1)) goto fail;
5701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5702 if (SWIG_arg_fail(1)) SWIG_fail;
5703 {
5704 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5705 if (SWIG_arg_fail(2)) SWIG_fail;
5706 if (arg2 == NULL) {
5707 SWIG_null_ref("wxBitmap");
5708 }
5709 if (SWIG_arg_fail(2)) SWIG_fail;
5710 }
5711 {
5712 PyThreadState* __tstate = wxPyBeginAllowThreads();
5713 (arg1)->CopyFromBitmap((wxBitmap const &)*arg2);
5714
5715 wxPyEndAllowThreads(__tstate);
5716 if (PyErr_Occurred()) SWIG_fail;
5717 }
5718 Py_INCREF(Py_None); resultobj = Py_None;
5719 return resultobj;
5720 fail:
5721 return NULL;
5722 }
5723
5724
5725 static PyObject * Icon_swigregister(PyObject *, PyObject *args) {
5726 PyObject *obj;
5727 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5728 SWIG_TypeClientData(SWIGTYPE_p_wxIcon, obj);
5729 Py_INCREF(obj);
5730 return Py_BuildValue((char *)"");
5731 }
5732 static PyObject *_wrap_new_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5733 PyObject *resultobj;
5734 wxString *arg1 = (wxString *) &wxPyEmptyString ;
5735 int arg2 = (int) 0 ;
5736 wxIconLocation *result;
5737 bool temp1 = false ;
5738 PyObject * obj0 = 0 ;
5739 PyObject * obj1 = 0 ;
5740 char *kwnames[] = {
5741 (char *) "filename",(char *) "num", NULL
5742 };
5743
5744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconLocation",kwnames,&obj0,&obj1)) goto fail;
5745 if (obj0) {
5746 {
5747 arg1 = wxString_in_helper(obj0);
5748 if (arg1 == NULL) SWIG_fail;
5749 temp1 = true;
5750 }
5751 }
5752 if (obj1) {
5753 {
5754 arg2 = (int)(SWIG_As_int(obj1));
5755 if (SWIG_arg_fail(2)) SWIG_fail;
5756 }
5757 }
5758 {
5759 PyThreadState* __tstate = wxPyBeginAllowThreads();
5760 result = (wxIconLocation *)new_wxIconLocation((wxString const *)arg1,arg2);
5761
5762 wxPyEndAllowThreads(__tstate);
5763 if (PyErr_Occurred()) SWIG_fail;
5764 }
5765 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconLocation, 1);
5766 {
5767 if (temp1)
5768 delete arg1;
5769 }
5770 return resultobj;
5771 fail:
5772 {
5773 if (temp1)
5774 delete arg1;
5775 }
5776 return NULL;
5777 }
5778
5779
5780 static PyObject *_wrap_delete_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5781 PyObject *resultobj;
5782 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5783 PyObject * obj0 = 0 ;
5784 char *kwnames[] = {
5785 (char *) "self", NULL
5786 };
5787
5788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconLocation",kwnames,&obj0)) goto fail;
5789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5790 if (SWIG_arg_fail(1)) SWIG_fail;
5791 {
5792 PyThreadState* __tstate = wxPyBeginAllowThreads();
5793 delete arg1;
5794
5795 wxPyEndAllowThreads(__tstate);
5796 if (PyErr_Occurred()) SWIG_fail;
5797 }
5798 Py_INCREF(Py_None); resultobj = Py_None;
5799 return resultobj;
5800 fail:
5801 return NULL;
5802 }
5803
5804
5805 static PyObject *_wrap_IconLocation_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
5806 PyObject *resultobj;
5807 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5808 bool result;
5809 PyObject * obj0 = 0 ;
5810 char *kwnames[] = {
5811 (char *) "self", NULL
5812 };
5813
5814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_IsOk",kwnames,&obj0)) goto fail;
5815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5816 if (SWIG_arg_fail(1)) SWIG_fail;
5817 {
5818 PyThreadState* __tstate = wxPyBeginAllowThreads();
5819 result = (bool)((wxIconLocation const *)arg1)->IsOk();
5820
5821 wxPyEndAllowThreads(__tstate);
5822 if (PyErr_Occurred()) SWIG_fail;
5823 }
5824 {
5825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5826 }
5827 return resultobj;
5828 fail:
5829 return NULL;
5830 }
5831
5832
5833 static PyObject *_wrap_IconLocation_SetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5834 PyObject *resultobj;
5835 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5836 wxString *arg2 = 0 ;
5837 bool temp2 = false ;
5838 PyObject * obj0 = 0 ;
5839 PyObject * obj1 = 0 ;
5840 char *kwnames[] = {
5841 (char *) "self",(char *) "filename", NULL
5842 };
5843
5844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetFileName",kwnames,&obj0,&obj1)) goto fail;
5845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5846 if (SWIG_arg_fail(1)) SWIG_fail;
5847 {
5848 arg2 = wxString_in_helper(obj1);
5849 if (arg2 == NULL) SWIG_fail;
5850 temp2 = true;
5851 }
5852 {
5853 PyThreadState* __tstate = wxPyBeginAllowThreads();
5854 (arg1)->SetFileName((wxString const &)*arg2);
5855
5856 wxPyEndAllowThreads(__tstate);
5857 if (PyErr_Occurred()) SWIG_fail;
5858 }
5859 Py_INCREF(Py_None); resultobj = Py_None;
5860 {
5861 if (temp2)
5862 delete arg2;
5863 }
5864 return resultobj;
5865 fail:
5866 {
5867 if (temp2)
5868 delete arg2;
5869 }
5870 return NULL;
5871 }
5872
5873
5874 static PyObject *_wrap_IconLocation_GetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5875 PyObject *resultobj;
5876 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5877 wxString *result;
5878 PyObject * obj0 = 0 ;
5879 char *kwnames[] = {
5880 (char *) "self", NULL
5881 };
5882
5883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetFileName",kwnames,&obj0)) goto fail;
5884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5885 if (SWIG_arg_fail(1)) SWIG_fail;
5886 {
5887 PyThreadState* __tstate = wxPyBeginAllowThreads();
5888 {
5889 wxString const &_result_ref = ((wxIconLocation const *)arg1)->GetFileName();
5890 result = (wxString *) &_result_ref;
5891 }
5892
5893 wxPyEndAllowThreads(__tstate);
5894 if (PyErr_Occurred()) SWIG_fail;
5895 }
5896 {
5897 #if wxUSE_UNICODE
5898 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
5899 #else
5900 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
5901 #endif
5902 }
5903 return resultobj;
5904 fail:
5905 return NULL;
5906 }
5907
5908
5909 static PyObject *_wrap_IconLocation_SetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5910 PyObject *resultobj;
5911 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5912 int arg2 ;
5913 PyObject * obj0 = 0 ;
5914 PyObject * obj1 = 0 ;
5915 char *kwnames[] = {
5916 (char *) "self",(char *) "num", NULL
5917 };
5918
5919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetIndex",kwnames,&obj0,&obj1)) goto fail;
5920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5921 if (SWIG_arg_fail(1)) SWIG_fail;
5922 {
5923 arg2 = (int)(SWIG_As_int(obj1));
5924 if (SWIG_arg_fail(2)) SWIG_fail;
5925 }
5926 {
5927 PyThreadState* __tstate = wxPyBeginAllowThreads();
5928 wxIconLocation_SetIndex(arg1,arg2);
5929
5930 wxPyEndAllowThreads(__tstate);
5931 if (PyErr_Occurred()) SWIG_fail;
5932 }
5933 Py_INCREF(Py_None); resultobj = Py_None;
5934 return resultobj;
5935 fail:
5936 return NULL;
5937 }
5938
5939
5940 static PyObject *_wrap_IconLocation_GetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5941 PyObject *resultobj;
5942 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5943 int result;
5944 PyObject * obj0 = 0 ;
5945 char *kwnames[] = {
5946 (char *) "self", NULL
5947 };
5948
5949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetIndex",kwnames,&obj0)) goto fail;
5950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5951 if (SWIG_arg_fail(1)) SWIG_fail;
5952 {
5953 PyThreadState* __tstate = wxPyBeginAllowThreads();
5954 result = (int)wxIconLocation_GetIndex(arg1);
5955
5956 wxPyEndAllowThreads(__tstate);
5957 if (PyErr_Occurred()) SWIG_fail;
5958 }
5959 {
5960 resultobj = SWIG_From_int((int)(result));
5961 }
5962 return resultobj;
5963 fail:
5964 return NULL;
5965 }
5966
5967
5968 static PyObject * IconLocation_swigregister(PyObject *, PyObject *args) {
5969 PyObject *obj;
5970 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5971 SWIG_TypeClientData(SWIGTYPE_p_wxIconLocation, obj);
5972 Py_INCREF(obj);
5973 return Py_BuildValue((char *)"");
5974 }
5975 static PyObject *_wrap_new_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5976 PyObject *resultobj;
5977 wxIconBundle *result;
5978 char *kwnames[] = {
5979 NULL
5980 };
5981
5982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IconBundle",kwnames)) goto fail;
5983 {
5984 PyThreadState* __tstate = wxPyBeginAllowThreads();
5985 result = (wxIconBundle *)new wxIconBundle();
5986
5987 wxPyEndAllowThreads(__tstate);
5988 if (PyErr_Occurred()) SWIG_fail;
5989 }
5990 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5991 return resultobj;
5992 fail:
5993 return NULL;
5994 }
5995
5996
5997 static PyObject *_wrap_new_IconBundleFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5998 PyObject *resultobj;
5999 wxString *arg1 = 0 ;
6000 long arg2 ;
6001 wxIconBundle *result;
6002 bool temp1 = false ;
6003 PyObject * obj0 = 0 ;
6004 PyObject * obj1 = 0 ;
6005 char *kwnames[] = {
6006 (char *) "file",(char *) "type", NULL
6007 };
6008
6009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_IconBundleFromFile",kwnames,&obj0,&obj1)) goto fail;
6010 {
6011 arg1 = wxString_in_helper(obj0);
6012 if (arg1 == NULL) SWIG_fail;
6013 temp1 = true;
6014 }
6015 {
6016 arg2 = (long)(SWIG_As_long(obj1));
6017 if (SWIG_arg_fail(2)) SWIG_fail;
6018 }
6019 {
6020 PyThreadState* __tstate = wxPyBeginAllowThreads();
6021 result = (wxIconBundle *)new wxIconBundle((wxString const &)*arg1,arg2);
6022
6023 wxPyEndAllowThreads(__tstate);
6024 if (PyErr_Occurred()) SWIG_fail;
6025 }
6026 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
6027 {
6028 if (temp1)
6029 delete arg1;
6030 }
6031 return resultobj;
6032 fail:
6033 {
6034 if (temp1)
6035 delete arg1;
6036 }
6037 return NULL;
6038 }
6039
6040
6041 static PyObject *_wrap_new_IconBundleFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
6042 PyObject *resultobj;
6043 wxIcon *arg1 = 0 ;
6044 wxIconBundle *result;
6045 PyObject * obj0 = 0 ;
6046 char *kwnames[] = {
6047 (char *) "icon", NULL
6048 };
6049
6050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconBundleFromIcon",kwnames,&obj0)) goto fail;
6051 {
6052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
6053 if (SWIG_arg_fail(1)) SWIG_fail;
6054 if (arg1 == NULL) {
6055 SWIG_null_ref("wxIcon");
6056 }
6057 if (SWIG_arg_fail(1)) SWIG_fail;
6058 }
6059 {
6060 PyThreadState* __tstate = wxPyBeginAllowThreads();
6061 result = (wxIconBundle *)new wxIconBundle((wxIcon const &)*arg1);
6062
6063 wxPyEndAllowThreads(__tstate);
6064 if (PyErr_Occurred()) SWIG_fail;
6065 }
6066 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
6067 return resultobj;
6068 fail:
6069 return NULL;
6070 }
6071
6072
6073 static PyObject *_wrap_delete_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
6074 PyObject *resultobj;
6075 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
6076 PyObject * obj0 = 0 ;
6077 char *kwnames[] = {
6078 (char *) "self", NULL
6079 };
6080
6081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconBundle",kwnames,&obj0)) goto fail;
6082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
6083 if (SWIG_arg_fail(1)) SWIG_fail;
6084 {
6085 PyThreadState* __tstate = wxPyBeginAllowThreads();
6086 delete arg1;
6087
6088 wxPyEndAllowThreads(__tstate);
6089 if (PyErr_Occurred()) SWIG_fail;
6090 }
6091 Py_INCREF(Py_None); resultobj = Py_None;
6092 return resultobj;
6093 fail:
6094 return NULL;
6095 }
6096
6097
6098 static PyObject *_wrap_IconBundle_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
6099 PyObject *resultobj;
6100 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
6101 wxIcon *arg2 = 0 ;
6102 PyObject * obj0 = 0 ;
6103 PyObject * obj1 = 0 ;
6104 char *kwnames[] = {
6105 (char *) "self",(char *) "icon", NULL
6106 };
6107
6108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_AddIcon",kwnames,&obj0,&obj1)) goto fail;
6109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
6110 if (SWIG_arg_fail(1)) SWIG_fail;
6111 {
6112 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
6113 if (SWIG_arg_fail(2)) SWIG_fail;
6114 if (arg2 == NULL) {
6115 SWIG_null_ref("wxIcon");
6116 }
6117 if (SWIG_arg_fail(2)) SWIG_fail;
6118 }
6119 {
6120 PyThreadState* __tstate = wxPyBeginAllowThreads();
6121 (arg1)->AddIcon((wxIcon const &)*arg2);
6122
6123 wxPyEndAllowThreads(__tstate);
6124 if (PyErr_Occurred()) SWIG_fail;
6125 }
6126 Py_INCREF(Py_None); resultobj = Py_None;
6127 return resultobj;
6128 fail:
6129 return NULL;
6130 }
6131
6132
6133 static PyObject *_wrap_IconBundle_AddIconFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
6134 PyObject *resultobj;
6135 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
6136 wxString *arg2 = 0 ;
6137 long arg3 ;
6138 bool temp2 = false ;
6139 PyObject * obj0 = 0 ;
6140 PyObject * obj1 = 0 ;
6141 PyObject * obj2 = 0 ;
6142 char *kwnames[] = {
6143 (char *) "self",(char *) "file",(char *) "type", NULL
6144 };
6145
6146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IconBundle_AddIconFromFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
6147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
6148 if (SWIG_arg_fail(1)) SWIG_fail;
6149 {
6150 arg2 = wxString_in_helper(obj1);
6151 if (arg2 == NULL) SWIG_fail;
6152 temp2 = true;
6153 }
6154 {
6155 arg3 = (long)(SWIG_As_long(obj2));
6156 if (SWIG_arg_fail(3)) SWIG_fail;
6157 }
6158 {
6159 PyThreadState* __tstate = wxPyBeginAllowThreads();
6160 (arg1)->AddIcon((wxString const &)*arg2,arg3);
6161
6162 wxPyEndAllowThreads(__tstate);
6163 if (PyErr_Occurred()) SWIG_fail;
6164 }
6165 Py_INCREF(Py_None); resultobj = Py_None;
6166 {
6167 if (temp2)
6168 delete arg2;
6169 }
6170 return resultobj;
6171 fail:
6172 {
6173 if (temp2)
6174 delete arg2;
6175 }
6176 return NULL;
6177 }
6178
6179
6180 static PyObject *_wrap_IconBundle_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
6181 PyObject *resultobj;
6182 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
6183 wxSize *arg2 = 0 ;
6184 wxIcon *result;
6185 wxSize temp2 ;
6186 PyObject * obj0 = 0 ;
6187 PyObject * obj1 = 0 ;
6188 char *kwnames[] = {
6189 (char *) "self",(char *) "size", NULL
6190 };
6191
6192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_GetIcon",kwnames,&obj0,&obj1)) goto fail;
6193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
6194 if (SWIG_arg_fail(1)) SWIG_fail;
6195 {
6196 arg2 = &temp2;
6197 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6198 }
6199 {
6200 PyThreadState* __tstate = wxPyBeginAllowThreads();
6201 {
6202 wxIcon const &_result_ref = ((wxIconBundle const *)arg1)->GetIcon((wxSize const &)*arg2);
6203 result = (wxIcon *) &_result_ref;
6204 }
6205
6206 wxPyEndAllowThreads(__tstate);
6207 if (PyErr_Occurred()) SWIG_fail;
6208 }
6209 {
6210 wxIcon* resultptr = new wxIcon(*result);
6211 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxIcon, 1);
6212 }
6213 return resultobj;
6214 fail:
6215 return NULL;
6216 }
6217
6218
6219 static PyObject * IconBundle_swigregister(PyObject *, PyObject *args) {
6220 PyObject *obj;
6221 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6222 SWIG_TypeClientData(SWIGTYPE_p_wxIconBundle, obj);
6223 Py_INCREF(obj);
6224 return Py_BuildValue((char *)"");
6225 }
6226 static PyObject *_wrap_new_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
6227 PyObject *resultobj;
6228 wxString *arg1 = 0 ;
6229 long arg2 ;
6230 int arg3 = (int) 0 ;
6231 int arg4 = (int) 0 ;
6232 wxCursor *result;
6233 bool temp1 = false ;
6234 PyObject * obj0 = 0 ;
6235 PyObject * obj1 = 0 ;
6236 PyObject * obj2 = 0 ;
6237 PyObject * obj3 = 0 ;
6238 char *kwnames[] = {
6239 (char *) "cursorName",(char *) "type",(char *) "hotSpotX",(char *) "hotSpotY", NULL
6240 };
6241
6242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Cursor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6243 {
6244 arg1 = wxString_in_helper(obj0);
6245 if (arg1 == NULL) SWIG_fail;
6246 temp1 = true;
6247 }
6248 {
6249 arg2 = (long)(SWIG_As_long(obj1));
6250 if (SWIG_arg_fail(2)) SWIG_fail;
6251 }
6252 if (obj2) {
6253 {
6254 arg3 = (int)(SWIG_As_int(obj2));
6255 if (SWIG_arg_fail(3)) SWIG_fail;
6256 }
6257 }
6258 if (obj3) {
6259 {
6260 arg4 = (int)(SWIG_As_int(obj3));
6261 if (SWIG_arg_fail(4)) SWIG_fail;
6262 }
6263 }
6264 {
6265 if (!wxPyCheckForApp()) SWIG_fail;
6266 PyThreadState* __tstate = wxPyBeginAllowThreads();
6267 result = (wxCursor *)new_wxCursor((wxString const &)*arg1,arg2,arg3,arg4);
6268
6269 wxPyEndAllowThreads(__tstate);
6270 if (PyErr_Occurred()) SWIG_fail;
6271 }
6272 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6273 {
6274 if (temp1)
6275 delete arg1;
6276 }
6277 return resultobj;
6278 fail:
6279 {
6280 if (temp1)
6281 delete arg1;
6282 }
6283 return NULL;
6284 }
6285
6286
6287 static PyObject *_wrap_delete_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
6288 PyObject *resultobj;
6289 wxCursor *arg1 = (wxCursor *) 0 ;
6290 PyObject * obj0 = 0 ;
6291 char *kwnames[] = {
6292 (char *) "self", NULL
6293 };
6294
6295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Cursor",kwnames,&obj0)) goto fail;
6296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6297 if (SWIG_arg_fail(1)) SWIG_fail;
6298 {
6299 PyThreadState* __tstate = wxPyBeginAllowThreads();
6300 delete arg1;
6301
6302 wxPyEndAllowThreads(__tstate);
6303 if (PyErr_Occurred()) SWIG_fail;
6304 }
6305 Py_INCREF(Py_None); resultobj = Py_None;
6306 return resultobj;
6307 fail:
6308 return NULL;
6309 }
6310
6311
6312 static PyObject *_wrap_new_StockCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6313 PyObject *resultobj;
6314 int arg1 ;
6315 wxCursor *result;
6316 PyObject * obj0 = 0 ;
6317 char *kwnames[] = {
6318 (char *) "id", NULL
6319 };
6320
6321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_StockCursor",kwnames,&obj0)) goto fail;
6322 {
6323 arg1 = (int)(SWIG_As_int(obj0));
6324 if (SWIG_arg_fail(1)) SWIG_fail;
6325 }
6326 {
6327 if (!wxPyCheckForApp()) SWIG_fail;
6328 PyThreadState* __tstate = wxPyBeginAllowThreads();
6329 result = (wxCursor *)new wxCursor(arg1);
6330
6331 wxPyEndAllowThreads(__tstate);
6332 if (PyErr_Occurred()) SWIG_fail;
6333 }
6334 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6335 return resultobj;
6336 fail:
6337 return NULL;
6338 }
6339
6340
6341 static PyObject *_wrap_new_CursorFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
6342 PyObject *resultobj;
6343 wxImage *arg1 = 0 ;
6344 wxCursor *result;
6345 PyObject * obj0 = 0 ;
6346 char *kwnames[] = {
6347 (char *) "image", NULL
6348 };
6349
6350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CursorFromImage",kwnames,&obj0)) goto fail;
6351 {
6352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
6353 if (SWIG_arg_fail(1)) SWIG_fail;
6354 if (arg1 == NULL) {
6355 SWIG_null_ref("wxImage");
6356 }
6357 if (SWIG_arg_fail(1)) SWIG_fail;
6358 }
6359 {
6360 if (!wxPyCheckForApp()) SWIG_fail;
6361 PyThreadState* __tstate = wxPyBeginAllowThreads();
6362 result = (wxCursor *)new wxCursor((wxImage const &)*arg1);
6363
6364 wxPyEndAllowThreads(__tstate);
6365 if (PyErr_Occurred()) SWIG_fail;
6366 }
6367 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6368 return resultobj;
6369 fail:
6370 return NULL;
6371 }
6372
6373
6374 static PyObject *_wrap_Cursor_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
6375 PyObject *resultobj;
6376 wxCursor *arg1 = (wxCursor *) 0 ;
6377 long result;
6378 PyObject * obj0 = 0 ;
6379 char *kwnames[] = {
6380 (char *) "self", NULL
6381 };
6382
6383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_GetHandle",kwnames,&obj0)) goto fail;
6384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6385 if (SWIG_arg_fail(1)) SWIG_fail;
6386 {
6387 PyThreadState* __tstate = wxPyBeginAllowThreads();
6388 result = (long)(arg1)->GetHandle();
6389
6390 wxPyEndAllowThreads(__tstate);
6391 if (PyErr_Occurred()) SWIG_fail;
6392 }
6393 {
6394 resultobj = SWIG_From_long((long)(result));
6395 }
6396 return resultobj;
6397 fail:
6398 return NULL;
6399 }
6400
6401
6402 static PyObject *_wrap_Cursor_SetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
6403 PyObject *resultobj;
6404 wxCursor *arg1 = (wxCursor *) 0 ;
6405 long arg2 ;
6406 PyObject * obj0 = 0 ;
6407 PyObject * obj1 = 0 ;
6408 char *kwnames[] = {
6409 (char *) "self",(char *) "handle", NULL
6410 };
6411
6412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetHandle",kwnames,&obj0,&obj1)) goto fail;
6413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6414 if (SWIG_arg_fail(1)) SWIG_fail;
6415 {
6416 arg2 = (long)(SWIG_As_long(obj1));
6417 if (SWIG_arg_fail(2)) SWIG_fail;
6418 }
6419 {
6420 PyThreadState* __tstate = wxPyBeginAllowThreads();
6421 wxCursor_SetHandle(arg1,arg2);
6422
6423 wxPyEndAllowThreads(__tstate);
6424 if (PyErr_Occurred()) SWIG_fail;
6425 }
6426 Py_INCREF(Py_None); resultobj = Py_None;
6427 return resultobj;
6428 fail:
6429 return NULL;
6430 }
6431
6432
6433 static PyObject *_wrap_Cursor_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
6434 PyObject *resultobj;
6435 wxCursor *arg1 = (wxCursor *) 0 ;
6436 bool result;
6437 PyObject * obj0 = 0 ;
6438 char *kwnames[] = {
6439 (char *) "self", NULL
6440 };
6441
6442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_Ok",kwnames,&obj0)) goto fail;
6443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6444 if (SWIG_arg_fail(1)) SWIG_fail;
6445 {
6446 PyThreadState* __tstate = wxPyBeginAllowThreads();
6447 result = (bool)(arg1)->Ok();
6448
6449 wxPyEndAllowThreads(__tstate);
6450 if (PyErr_Occurred()) SWIG_fail;
6451 }
6452 {
6453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6454 }
6455 return resultobj;
6456 fail:
6457 return NULL;
6458 }
6459
6460
6461 static PyObject *_wrap_Cursor_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
6462 PyObject *resultobj;
6463 wxCursor *arg1 = (wxCursor *) 0 ;
6464 int result;
6465 PyObject * obj0 = 0 ;
6466 char *kwnames[] = {
6467 (char *) "self", NULL
6468 };
6469
6470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_GetWidth",kwnames,&obj0)) goto fail;
6471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6472 if (SWIG_arg_fail(1)) SWIG_fail;
6473 {
6474 PyThreadState* __tstate = wxPyBeginAllowThreads();
6475 result = (int)(arg1)->GetWidth();
6476
6477 wxPyEndAllowThreads(__tstate);
6478 if (PyErr_Occurred()) SWIG_fail;
6479 }
6480 {
6481 resultobj = SWIG_From_int((int)(result));
6482 }
6483 return resultobj;
6484 fail:
6485 return NULL;
6486 }
6487
6488
6489 static PyObject *_wrap_Cursor_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
6490 PyObject *resultobj;
6491 wxCursor *arg1 = (wxCursor *) 0 ;
6492 int result;
6493 PyObject * obj0 = 0 ;
6494 char *kwnames[] = {
6495 (char *) "self", NULL
6496 };
6497
6498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_GetHeight",kwnames,&obj0)) goto fail;
6499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6500 if (SWIG_arg_fail(1)) SWIG_fail;
6501 {
6502 PyThreadState* __tstate = wxPyBeginAllowThreads();
6503 result = (int)(arg1)->GetHeight();
6504
6505 wxPyEndAllowThreads(__tstate);
6506 if (PyErr_Occurred()) SWIG_fail;
6507 }
6508 {
6509 resultobj = SWIG_From_int((int)(result));
6510 }
6511 return resultobj;
6512 fail:
6513 return NULL;
6514 }
6515
6516
6517 static PyObject *_wrap_Cursor_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
6518 PyObject *resultobj;
6519 wxCursor *arg1 = (wxCursor *) 0 ;
6520 int result;
6521 PyObject * obj0 = 0 ;
6522 char *kwnames[] = {
6523 (char *) "self", NULL
6524 };
6525
6526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_GetDepth",kwnames,&obj0)) goto fail;
6527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6528 if (SWIG_arg_fail(1)) SWIG_fail;
6529 {
6530 PyThreadState* __tstate = wxPyBeginAllowThreads();
6531 result = (int)(arg1)->GetDepth();
6532
6533 wxPyEndAllowThreads(__tstate);
6534 if (PyErr_Occurred()) SWIG_fail;
6535 }
6536 {
6537 resultobj = SWIG_From_int((int)(result));
6538 }
6539 return resultobj;
6540 fail:
6541 return NULL;
6542 }
6543
6544
6545 static PyObject *_wrap_Cursor_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
6546 PyObject *resultobj;
6547 wxCursor *arg1 = (wxCursor *) 0 ;
6548 int arg2 ;
6549 PyObject * obj0 = 0 ;
6550 PyObject * obj1 = 0 ;
6551 char *kwnames[] = {
6552 (char *) "self",(char *) "w", NULL
6553 };
6554
6555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetWidth",kwnames,&obj0,&obj1)) goto fail;
6556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6557 if (SWIG_arg_fail(1)) SWIG_fail;
6558 {
6559 arg2 = (int)(SWIG_As_int(obj1));
6560 if (SWIG_arg_fail(2)) SWIG_fail;
6561 }
6562 {
6563 PyThreadState* __tstate = wxPyBeginAllowThreads();
6564 (arg1)->SetWidth(arg2);
6565
6566 wxPyEndAllowThreads(__tstate);
6567 if (PyErr_Occurred()) SWIG_fail;
6568 }
6569 Py_INCREF(Py_None); resultobj = Py_None;
6570 return resultobj;
6571 fail:
6572 return NULL;
6573 }
6574
6575
6576 static PyObject *_wrap_Cursor_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
6577 PyObject *resultobj;
6578 wxCursor *arg1 = (wxCursor *) 0 ;
6579 int arg2 ;
6580 PyObject * obj0 = 0 ;
6581 PyObject * obj1 = 0 ;
6582 char *kwnames[] = {
6583 (char *) "self",(char *) "h", NULL
6584 };
6585
6586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetHeight",kwnames,&obj0,&obj1)) goto fail;
6587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6588 if (SWIG_arg_fail(1)) SWIG_fail;
6589 {
6590 arg2 = (int)(SWIG_As_int(obj1));
6591 if (SWIG_arg_fail(2)) SWIG_fail;
6592 }
6593 {
6594 PyThreadState* __tstate = wxPyBeginAllowThreads();
6595 (arg1)->SetHeight(arg2);
6596
6597 wxPyEndAllowThreads(__tstate);
6598 if (PyErr_Occurred()) SWIG_fail;
6599 }
6600 Py_INCREF(Py_None); resultobj = Py_None;
6601 return resultobj;
6602 fail:
6603 return NULL;
6604 }
6605
6606
6607 static PyObject *_wrap_Cursor_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
6608 PyObject *resultobj;
6609 wxCursor *arg1 = (wxCursor *) 0 ;
6610 int arg2 ;
6611 PyObject * obj0 = 0 ;
6612 PyObject * obj1 = 0 ;
6613 char *kwnames[] = {
6614 (char *) "self",(char *) "d", NULL
6615 };
6616
6617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetDepth",kwnames,&obj0,&obj1)) goto fail;
6618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6619 if (SWIG_arg_fail(1)) SWIG_fail;
6620 {
6621 arg2 = (int)(SWIG_As_int(obj1));
6622 if (SWIG_arg_fail(2)) SWIG_fail;
6623 }
6624 {
6625 PyThreadState* __tstate = wxPyBeginAllowThreads();
6626 (arg1)->SetDepth(arg2);
6627
6628 wxPyEndAllowThreads(__tstate);
6629 if (PyErr_Occurred()) SWIG_fail;
6630 }
6631 Py_INCREF(Py_None); resultobj = Py_None;
6632 return resultobj;
6633 fail:
6634 return NULL;
6635 }
6636
6637
6638 static PyObject *_wrap_Cursor_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6639 PyObject *resultobj;
6640 wxCursor *arg1 = (wxCursor *) 0 ;
6641 wxSize *arg2 = 0 ;
6642 wxSize temp2 ;
6643 PyObject * obj0 = 0 ;
6644 PyObject * obj1 = 0 ;
6645 char *kwnames[] = {
6646 (char *) "self",(char *) "size", NULL
6647 };
6648
6649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetSize",kwnames,&obj0,&obj1)) goto fail;
6650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6651 if (SWIG_arg_fail(1)) SWIG_fail;
6652 {
6653 arg2 = &temp2;
6654 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6655 }
6656 {
6657 PyThreadState* __tstate = wxPyBeginAllowThreads();
6658 (arg1)->SetSize((wxSize const &)*arg2);
6659
6660 wxPyEndAllowThreads(__tstate);
6661 if (PyErr_Occurred()) SWIG_fail;
6662 }
6663 Py_INCREF(Py_None); resultobj = Py_None;
6664 return resultobj;
6665 fail:
6666 return NULL;
6667 }
6668
6669
6670 static PyObject * Cursor_swigregister(PyObject *, PyObject *args) {
6671 PyObject *obj;
6672 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6673 SWIG_TypeClientData(SWIGTYPE_p_wxCursor, obj);
6674 Py_INCREF(obj);
6675 return Py_BuildValue((char *)"");
6676 }
6677 static PyObject *_wrap_new_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6678 PyObject *resultobj;
6679 int arg1 = (int) 0 ;
6680 int arg2 = (int) 0 ;
6681 int arg3 = (int) 0 ;
6682 int arg4 = (int) 0 ;
6683 wxRegion *result;
6684 PyObject * obj0 = 0 ;
6685 PyObject * obj1 = 0 ;
6686 PyObject * obj2 = 0 ;
6687 PyObject * obj3 = 0 ;
6688 char *kwnames[] = {
6689 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6690 };
6691
6692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Region",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6693 if (obj0) {
6694 {
6695 arg1 = (int)(SWIG_As_int(obj0));
6696 if (SWIG_arg_fail(1)) SWIG_fail;
6697 }
6698 }
6699 if (obj1) {
6700 {
6701 arg2 = (int)(SWIG_As_int(obj1));
6702 if (SWIG_arg_fail(2)) SWIG_fail;
6703 }
6704 }
6705 if (obj2) {
6706 {
6707 arg3 = (int)(SWIG_As_int(obj2));
6708 if (SWIG_arg_fail(3)) SWIG_fail;
6709 }
6710 }
6711 if (obj3) {
6712 {
6713 arg4 = (int)(SWIG_As_int(obj3));
6714 if (SWIG_arg_fail(4)) SWIG_fail;
6715 }
6716 }
6717 {
6718 if (!wxPyCheckForApp()) SWIG_fail;
6719 PyThreadState* __tstate = wxPyBeginAllowThreads();
6720 result = (wxRegion *)new wxRegion(arg1,arg2,arg3,arg4);
6721
6722 wxPyEndAllowThreads(__tstate);
6723 if (PyErr_Occurred()) SWIG_fail;
6724 }
6725 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6726 return resultobj;
6727 fail:
6728 return NULL;
6729 }
6730
6731
6732 static PyObject *_wrap_new_RegionFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6733 PyObject *resultobj;
6734 wxBitmap *arg1 = 0 ;
6735 wxRegion *result;
6736 PyObject * obj0 = 0 ;
6737 char *kwnames[] = {
6738 (char *) "bmp", NULL
6739 };
6740
6741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionFromBitmap",kwnames,&obj0)) goto fail;
6742 {
6743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6744 if (SWIG_arg_fail(1)) SWIG_fail;
6745 if (arg1 == NULL) {
6746 SWIG_null_ref("wxBitmap");
6747 }
6748 if (SWIG_arg_fail(1)) SWIG_fail;
6749 }
6750 {
6751 if (!wxPyCheckForApp()) SWIG_fail;
6752 PyThreadState* __tstate = wxPyBeginAllowThreads();
6753 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1);
6754
6755 wxPyEndAllowThreads(__tstate);
6756 if (PyErr_Occurred()) SWIG_fail;
6757 }
6758 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6759 return resultobj;
6760 fail:
6761 return NULL;
6762 }
6763
6764
6765 static PyObject *_wrap_new_RegionFromBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
6766 PyObject *resultobj;
6767 wxBitmap *arg1 = 0 ;
6768 wxColour *arg2 = 0 ;
6769 int arg3 = (int) 0 ;
6770 wxRegion *result;
6771 wxColour temp2 ;
6772 PyObject * obj0 = 0 ;
6773 PyObject * obj1 = 0 ;
6774 PyObject * obj2 = 0 ;
6775 char *kwnames[] = {
6776 (char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
6777 };
6778
6779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_RegionFromBitmapColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
6780 {
6781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6782 if (SWIG_arg_fail(1)) SWIG_fail;
6783 if (arg1 == NULL) {
6784 SWIG_null_ref("wxBitmap");
6785 }
6786 if (SWIG_arg_fail(1)) SWIG_fail;
6787 }
6788 {
6789 arg2 = &temp2;
6790 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6791 }
6792 if (obj2) {
6793 {
6794 arg3 = (int)(SWIG_As_int(obj2));
6795 if (SWIG_arg_fail(3)) SWIG_fail;
6796 }
6797 }
6798 {
6799 if (!wxPyCheckForApp()) SWIG_fail;
6800 PyThreadState* __tstate = wxPyBeginAllowThreads();
6801 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1,(wxColour const &)*arg2,arg3);
6802
6803 wxPyEndAllowThreads(__tstate);
6804 if (PyErr_Occurred()) SWIG_fail;
6805 }
6806 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6807 return resultobj;
6808 fail:
6809 return NULL;
6810 }
6811
6812
6813 static PyObject *_wrap_new_RegionFromPoints(PyObject *, PyObject *args, PyObject *kwargs) {
6814 PyObject *resultobj;
6815 int arg1 ;
6816 wxPoint *arg2 = (wxPoint *) 0 ;
6817 int arg3 = (int) wxWINDING_RULE ;
6818 wxRegion *result;
6819 PyObject * obj0 = 0 ;
6820 PyObject * obj1 = 0 ;
6821 char *kwnames[] = {
6822 (char *) "points",(char *) "fillStyle", NULL
6823 };
6824
6825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_RegionFromPoints",kwnames,&obj0,&obj1)) goto fail;
6826 {
6827 arg2 = wxPoint_LIST_helper(obj0, &arg1);
6828 if (arg2 == NULL) SWIG_fail;
6829 }
6830 if (obj1) {
6831 {
6832 arg3 = (int)(SWIG_As_int(obj1));
6833 if (SWIG_arg_fail(3)) SWIG_fail;
6834 }
6835 }
6836 {
6837 if (!wxPyCheckForApp()) SWIG_fail;
6838 PyThreadState* __tstate = wxPyBeginAllowThreads();
6839 result = (wxRegion *)new wxRegion(arg1,arg2,arg3);
6840
6841 wxPyEndAllowThreads(__tstate);
6842 if (PyErr_Occurred()) SWIG_fail;
6843 }
6844 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6845 {
6846 if (arg2) delete [] arg2;
6847 }
6848 return resultobj;
6849 fail:
6850 {
6851 if (arg2) delete [] arg2;
6852 }
6853 return NULL;
6854 }
6855
6856
6857 static PyObject *_wrap_delete_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6858 PyObject *resultobj;
6859 wxRegion *arg1 = (wxRegion *) 0 ;
6860 PyObject * obj0 = 0 ;
6861 char *kwnames[] = {
6862 (char *) "self", NULL
6863 };
6864
6865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Region",kwnames,&obj0)) goto fail;
6866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6867 if (SWIG_arg_fail(1)) SWIG_fail;
6868 {
6869 PyThreadState* __tstate = wxPyBeginAllowThreads();
6870 delete arg1;
6871
6872 wxPyEndAllowThreads(__tstate);
6873 if (PyErr_Occurred()) SWIG_fail;
6874 }
6875 Py_INCREF(Py_None); resultobj = Py_None;
6876 return resultobj;
6877 fail:
6878 return NULL;
6879 }
6880
6881
6882 static PyObject *_wrap_Region_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
6883 PyObject *resultobj;
6884 wxRegion *arg1 = (wxRegion *) 0 ;
6885 PyObject * obj0 = 0 ;
6886 char *kwnames[] = {
6887 (char *) "self", NULL
6888 };
6889
6890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_Clear",kwnames,&obj0)) goto fail;
6891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6892 if (SWIG_arg_fail(1)) SWIG_fail;
6893 {
6894 PyThreadState* __tstate = wxPyBeginAllowThreads();
6895 (arg1)->Clear();
6896
6897 wxPyEndAllowThreads(__tstate);
6898 if (PyErr_Occurred()) SWIG_fail;
6899 }
6900 Py_INCREF(Py_None); resultobj = Py_None;
6901 return resultobj;
6902 fail:
6903 return NULL;
6904 }
6905
6906
6907 static PyObject *_wrap_Region_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
6908 PyObject *resultobj;
6909 wxRegion *arg1 = (wxRegion *) 0 ;
6910 int arg2 ;
6911 int arg3 ;
6912 bool result;
6913 PyObject * obj0 = 0 ;
6914 PyObject * obj1 = 0 ;
6915 PyObject * obj2 = 0 ;
6916 char *kwnames[] = {
6917 (char *) "self",(char *) "x",(char *) "y", NULL
6918 };
6919
6920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Offset",kwnames,&obj0,&obj1,&obj2)) goto fail;
6921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6922 if (SWIG_arg_fail(1)) SWIG_fail;
6923 {
6924 arg2 = (int)(SWIG_As_int(obj1));
6925 if (SWIG_arg_fail(2)) SWIG_fail;
6926 }
6927 {
6928 arg3 = (int)(SWIG_As_int(obj2));
6929 if (SWIG_arg_fail(3)) SWIG_fail;
6930 }
6931 {
6932 PyThreadState* __tstate = wxPyBeginAllowThreads();
6933 result = (bool)(arg1)->Offset(arg2,arg3);
6934
6935 wxPyEndAllowThreads(__tstate);
6936 if (PyErr_Occurred()) SWIG_fail;
6937 }
6938 {
6939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6940 }
6941 return resultobj;
6942 fail:
6943 return NULL;
6944 }
6945
6946
6947 static PyObject *_wrap_Region_Contains(PyObject *, PyObject *args, PyObject *kwargs) {
6948 PyObject *resultobj;
6949 wxRegion *arg1 = (wxRegion *) 0 ;
6950 int arg2 ;
6951 int arg3 ;
6952 wxRegionContain result;
6953 PyObject * obj0 = 0 ;
6954 PyObject * obj1 = 0 ;
6955 PyObject * obj2 = 0 ;
6956 char *kwnames[] = {
6957 (char *) "self",(char *) "x",(char *) "y", NULL
6958 };
6959
6960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Contains",kwnames,&obj0,&obj1,&obj2)) goto fail;
6961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6962 if (SWIG_arg_fail(1)) SWIG_fail;
6963 {
6964 arg2 = (int)(SWIG_As_int(obj1));
6965 if (SWIG_arg_fail(2)) SWIG_fail;
6966 }
6967 {
6968 arg3 = (int)(SWIG_As_int(obj2));
6969 if (SWIG_arg_fail(3)) SWIG_fail;
6970 }
6971 {
6972 PyThreadState* __tstate = wxPyBeginAllowThreads();
6973 result = (wxRegionContain)(arg1)->Contains(arg2,arg3);
6974
6975 wxPyEndAllowThreads(__tstate);
6976 if (PyErr_Occurred()) SWIG_fail;
6977 }
6978 resultobj = SWIG_From_int((result));
6979 return resultobj;
6980 fail:
6981 return NULL;
6982 }
6983
6984
6985 static PyObject *_wrap_Region_ContainsPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6986 PyObject *resultobj;
6987 wxRegion *arg1 = (wxRegion *) 0 ;
6988 wxPoint *arg2 = 0 ;
6989 wxRegionContain result;
6990 wxPoint temp2 ;
6991 PyObject * obj0 = 0 ;
6992 PyObject * obj1 = 0 ;
6993 char *kwnames[] = {
6994 (char *) "self",(char *) "pt", NULL
6995 };
6996
6997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsPoint",kwnames,&obj0,&obj1)) goto fail;
6998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6999 if (SWIG_arg_fail(1)) SWIG_fail;
7000 {
7001 arg2 = &temp2;
7002 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7003 }
7004 {
7005 PyThreadState* __tstate = wxPyBeginAllowThreads();
7006 result = (wxRegionContain)(arg1)->Contains((wxPoint const &)*arg2);
7007
7008 wxPyEndAllowThreads(__tstate);
7009 if (PyErr_Occurred()) SWIG_fail;
7010 }
7011 resultobj = SWIG_From_int((result));
7012 return resultobj;
7013 fail:
7014 return NULL;
7015 }
7016
7017
7018 static PyObject *_wrap_Region_ContainsRect(PyObject *, PyObject *args, PyObject *kwargs) {
7019 PyObject *resultobj;
7020 wxRegion *arg1 = (wxRegion *) 0 ;
7021 wxRect *arg2 = 0 ;
7022 wxRegionContain result;
7023 wxRect temp2 ;
7024 PyObject * obj0 = 0 ;
7025 PyObject * obj1 = 0 ;
7026 char *kwnames[] = {
7027 (char *) "self",(char *) "rect", NULL
7028 };
7029
7030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsRect",kwnames,&obj0,&obj1)) goto fail;
7031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7032 if (SWIG_arg_fail(1)) SWIG_fail;
7033 {
7034 arg2 = &temp2;
7035 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7036 }
7037 {
7038 PyThreadState* __tstate = wxPyBeginAllowThreads();
7039 result = (wxRegionContain)(arg1)->Contains((wxRect const &)*arg2);
7040
7041 wxPyEndAllowThreads(__tstate);
7042 if (PyErr_Occurred()) SWIG_fail;
7043 }
7044 resultobj = SWIG_From_int((result));
7045 return resultobj;
7046 fail:
7047 return NULL;
7048 }
7049
7050
7051 static PyObject *_wrap_Region_ContainsRectDim(PyObject *, PyObject *args, PyObject *kwargs) {
7052 PyObject *resultobj;
7053 wxRegion *arg1 = (wxRegion *) 0 ;
7054 int arg2 ;
7055 int arg3 ;
7056 int arg4 ;
7057 int arg5 ;
7058 wxRegionContain result;
7059 PyObject * obj0 = 0 ;
7060 PyObject * obj1 = 0 ;
7061 PyObject * obj2 = 0 ;
7062 PyObject * obj3 = 0 ;
7063 PyObject * obj4 = 0 ;
7064 char *kwnames[] = {
7065 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
7066 };
7067
7068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_ContainsRectDim",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7070 if (SWIG_arg_fail(1)) SWIG_fail;
7071 {
7072 arg2 = (int)(SWIG_As_int(obj1));
7073 if (SWIG_arg_fail(2)) SWIG_fail;
7074 }
7075 {
7076 arg3 = (int)(SWIG_As_int(obj2));
7077 if (SWIG_arg_fail(3)) SWIG_fail;
7078 }
7079 {
7080 arg4 = (int)(SWIG_As_int(obj3));
7081 if (SWIG_arg_fail(4)) SWIG_fail;
7082 }
7083 {
7084 arg5 = (int)(SWIG_As_int(obj4));
7085 if (SWIG_arg_fail(5)) SWIG_fail;
7086 }
7087 {
7088 PyThreadState* __tstate = wxPyBeginAllowThreads();
7089 result = (wxRegionContain)(arg1)->Contains(arg2,arg3,arg4,arg5);
7090
7091 wxPyEndAllowThreads(__tstate);
7092 if (PyErr_Occurred()) SWIG_fail;
7093 }
7094 resultobj = SWIG_From_int((result));
7095 return resultobj;
7096 fail:
7097 return NULL;
7098 }
7099
7100
7101 static PyObject *_wrap_Region_GetBox(PyObject *, PyObject *args, PyObject *kwargs) {
7102 PyObject *resultobj;
7103 wxRegion *arg1 = (wxRegion *) 0 ;
7104 wxRect result;
7105 PyObject * obj0 = 0 ;
7106 char *kwnames[] = {
7107 (char *) "self", NULL
7108 };
7109
7110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_GetBox",kwnames,&obj0)) goto fail;
7111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7112 if (SWIG_arg_fail(1)) SWIG_fail;
7113 {
7114 PyThreadState* __tstate = wxPyBeginAllowThreads();
7115 result = (arg1)->GetBox();
7116
7117 wxPyEndAllowThreads(__tstate);
7118 if (PyErr_Occurred()) SWIG_fail;
7119 }
7120 {
7121 wxRect * resultptr;
7122 resultptr = new wxRect((wxRect &)(result));
7123 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
7124 }
7125 return resultobj;
7126 fail:
7127 return NULL;
7128 }
7129
7130
7131 static PyObject *_wrap_Region_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
7132 PyObject *resultobj;
7133 wxRegion *arg1 = (wxRegion *) 0 ;
7134 int arg2 ;
7135 int arg3 ;
7136 int arg4 ;
7137 int arg5 ;
7138 bool result;
7139 PyObject * obj0 = 0 ;
7140 PyObject * obj1 = 0 ;
7141 PyObject * obj2 = 0 ;
7142 PyObject * obj3 = 0 ;
7143 PyObject * obj4 = 0 ;
7144 char *kwnames[] = {
7145 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7146 };
7147
7148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Intersect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7150 if (SWIG_arg_fail(1)) SWIG_fail;
7151 {
7152 arg2 = (int)(SWIG_As_int(obj1));
7153 if (SWIG_arg_fail(2)) SWIG_fail;
7154 }
7155 {
7156 arg3 = (int)(SWIG_As_int(obj2));
7157 if (SWIG_arg_fail(3)) SWIG_fail;
7158 }
7159 {
7160 arg4 = (int)(SWIG_As_int(obj3));
7161 if (SWIG_arg_fail(4)) SWIG_fail;
7162 }
7163 {
7164 arg5 = (int)(SWIG_As_int(obj4));
7165 if (SWIG_arg_fail(5)) SWIG_fail;
7166 }
7167 {
7168 PyThreadState* __tstate = wxPyBeginAllowThreads();
7169 result = (bool)(arg1)->Intersect(arg2,arg3,arg4,arg5);
7170
7171 wxPyEndAllowThreads(__tstate);
7172 if (PyErr_Occurred()) SWIG_fail;
7173 }
7174 {
7175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7176 }
7177 return resultobj;
7178 fail:
7179 return NULL;
7180 }
7181
7182
7183 static PyObject *_wrap_Region_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
7184 PyObject *resultobj;
7185 wxRegion *arg1 = (wxRegion *) 0 ;
7186 wxRect *arg2 = 0 ;
7187 bool result;
7188 wxRect temp2 ;
7189 PyObject * obj0 = 0 ;
7190 PyObject * obj1 = 0 ;
7191 char *kwnames[] = {
7192 (char *) "self",(char *) "rect", NULL
7193 };
7194
7195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRect",kwnames,&obj0,&obj1)) goto fail;
7196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7197 if (SWIG_arg_fail(1)) SWIG_fail;
7198 {
7199 arg2 = &temp2;
7200 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7201 }
7202 {
7203 PyThreadState* __tstate = wxPyBeginAllowThreads();
7204 result = (bool)(arg1)->Intersect((wxRect const &)*arg2);
7205
7206 wxPyEndAllowThreads(__tstate);
7207 if (PyErr_Occurred()) SWIG_fail;
7208 }
7209 {
7210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7211 }
7212 return resultobj;
7213 fail:
7214 return NULL;
7215 }
7216
7217
7218 static PyObject *_wrap_Region_IntersectRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7219 PyObject *resultobj;
7220 wxRegion *arg1 = (wxRegion *) 0 ;
7221 wxRegion *arg2 = 0 ;
7222 bool result;
7223 PyObject * obj0 = 0 ;
7224 PyObject * obj1 = 0 ;
7225 char *kwnames[] = {
7226 (char *) "self",(char *) "region", NULL
7227 };
7228
7229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRegion",kwnames,&obj0,&obj1)) goto fail;
7230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7231 if (SWIG_arg_fail(1)) SWIG_fail;
7232 {
7233 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7234 if (SWIG_arg_fail(2)) SWIG_fail;
7235 if (arg2 == NULL) {
7236 SWIG_null_ref("wxRegion");
7237 }
7238 if (SWIG_arg_fail(2)) SWIG_fail;
7239 }
7240 {
7241 PyThreadState* __tstate = wxPyBeginAllowThreads();
7242 result = (bool)(arg1)->Intersect((wxRegion const &)*arg2);
7243
7244 wxPyEndAllowThreads(__tstate);
7245 if (PyErr_Occurred()) SWIG_fail;
7246 }
7247 {
7248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7249 }
7250 return resultobj;
7251 fail:
7252 return NULL;
7253 }
7254
7255
7256 static PyObject *_wrap_Region_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
7257 PyObject *resultobj;
7258 wxRegion *arg1 = (wxRegion *) 0 ;
7259 bool result;
7260 PyObject * obj0 = 0 ;
7261 char *kwnames[] = {
7262 (char *) "self", NULL
7263 };
7264
7265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_IsEmpty",kwnames,&obj0)) goto fail;
7266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7267 if (SWIG_arg_fail(1)) SWIG_fail;
7268 {
7269 PyThreadState* __tstate = wxPyBeginAllowThreads();
7270 result = (bool)(arg1)->IsEmpty();
7271
7272 wxPyEndAllowThreads(__tstate);
7273 if (PyErr_Occurred()) SWIG_fail;
7274 }
7275 {
7276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7277 }
7278 return resultobj;
7279 fail:
7280 return NULL;
7281 }
7282
7283
7284 static PyObject *_wrap_Region_Union(PyObject *, PyObject *args, PyObject *kwargs) {
7285 PyObject *resultobj;
7286 wxRegion *arg1 = (wxRegion *) 0 ;
7287 int arg2 ;
7288 int arg3 ;
7289 int arg4 ;
7290 int arg5 ;
7291 bool result;
7292 PyObject * obj0 = 0 ;
7293 PyObject * obj1 = 0 ;
7294 PyObject * obj2 = 0 ;
7295 PyObject * obj3 = 0 ;
7296 PyObject * obj4 = 0 ;
7297 char *kwnames[] = {
7298 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7299 };
7300
7301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Union",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7303 if (SWIG_arg_fail(1)) SWIG_fail;
7304 {
7305 arg2 = (int)(SWIG_As_int(obj1));
7306 if (SWIG_arg_fail(2)) SWIG_fail;
7307 }
7308 {
7309 arg3 = (int)(SWIG_As_int(obj2));
7310 if (SWIG_arg_fail(3)) SWIG_fail;
7311 }
7312 {
7313 arg4 = (int)(SWIG_As_int(obj3));
7314 if (SWIG_arg_fail(4)) SWIG_fail;
7315 }
7316 {
7317 arg5 = (int)(SWIG_As_int(obj4));
7318 if (SWIG_arg_fail(5)) SWIG_fail;
7319 }
7320 {
7321 PyThreadState* __tstate = wxPyBeginAllowThreads();
7322 result = (bool)(arg1)->Union(arg2,arg3,arg4,arg5);
7323
7324 wxPyEndAllowThreads(__tstate);
7325 if (PyErr_Occurred()) SWIG_fail;
7326 }
7327 {
7328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7329 }
7330 return resultobj;
7331 fail:
7332 return NULL;
7333 }
7334
7335
7336 static PyObject *_wrap_Region_UnionRect(PyObject *, PyObject *args, PyObject *kwargs) {
7337 PyObject *resultobj;
7338 wxRegion *arg1 = (wxRegion *) 0 ;
7339 wxRect *arg2 = 0 ;
7340 bool result;
7341 wxRect temp2 ;
7342 PyObject * obj0 = 0 ;
7343 PyObject * obj1 = 0 ;
7344 char *kwnames[] = {
7345 (char *) "self",(char *) "rect", NULL
7346 };
7347
7348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRect",kwnames,&obj0,&obj1)) goto fail;
7349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7350 if (SWIG_arg_fail(1)) SWIG_fail;
7351 {
7352 arg2 = &temp2;
7353 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7354 }
7355 {
7356 PyThreadState* __tstate = wxPyBeginAllowThreads();
7357 result = (bool)(arg1)->Union((wxRect const &)*arg2);
7358
7359 wxPyEndAllowThreads(__tstate);
7360 if (PyErr_Occurred()) SWIG_fail;
7361 }
7362 {
7363 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7364 }
7365 return resultobj;
7366 fail:
7367 return NULL;
7368 }
7369
7370
7371 static PyObject *_wrap_Region_UnionRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7372 PyObject *resultobj;
7373 wxRegion *arg1 = (wxRegion *) 0 ;
7374 wxRegion *arg2 = 0 ;
7375 bool result;
7376 PyObject * obj0 = 0 ;
7377 PyObject * obj1 = 0 ;
7378 char *kwnames[] = {
7379 (char *) "self",(char *) "region", NULL
7380 };
7381
7382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRegion",kwnames,&obj0,&obj1)) goto fail;
7383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7384 if (SWIG_arg_fail(1)) SWIG_fail;
7385 {
7386 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7387 if (SWIG_arg_fail(2)) SWIG_fail;
7388 if (arg2 == NULL) {
7389 SWIG_null_ref("wxRegion");
7390 }
7391 if (SWIG_arg_fail(2)) SWIG_fail;
7392 }
7393 {
7394 PyThreadState* __tstate = wxPyBeginAllowThreads();
7395 result = (bool)(arg1)->Union((wxRegion const &)*arg2);
7396
7397 wxPyEndAllowThreads(__tstate);
7398 if (PyErr_Occurred()) SWIG_fail;
7399 }
7400 {
7401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7402 }
7403 return resultobj;
7404 fail:
7405 return NULL;
7406 }
7407
7408
7409 static PyObject *_wrap_Region_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
7410 PyObject *resultobj;
7411 wxRegion *arg1 = (wxRegion *) 0 ;
7412 int arg2 ;
7413 int arg3 ;
7414 int arg4 ;
7415 int arg5 ;
7416 bool result;
7417 PyObject * obj0 = 0 ;
7418 PyObject * obj1 = 0 ;
7419 PyObject * obj2 = 0 ;
7420 PyObject * obj3 = 0 ;
7421 PyObject * obj4 = 0 ;
7422 char *kwnames[] = {
7423 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7424 };
7425
7426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Subtract",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7428 if (SWIG_arg_fail(1)) SWIG_fail;
7429 {
7430 arg2 = (int)(SWIG_As_int(obj1));
7431 if (SWIG_arg_fail(2)) SWIG_fail;
7432 }
7433 {
7434 arg3 = (int)(SWIG_As_int(obj2));
7435 if (SWIG_arg_fail(3)) SWIG_fail;
7436 }
7437 {
7438 arg4 = (int)(SWIG_As_int(obj3));
7439 if (SWIG_arg_fail(4)) SWIG_fail;
7440 }
7441 {
7442 arg5 = (int)(SWIG_As_int(obj4));
7443 if (SWIG_arg_fail(5)) SWIG_fail;
7444 }
7445 {
7446 PyThreadState* __tstate = wxPyBeginAllowThreads();
7447 result = (bool)(arg1)->Subtract(arg2,arg3,arg4,arg5);
7448
7449 wxPyEndAllowThreads(__tstate);
7450 if (PyErr_Occurred()) SWIG_fail;
7451 }
7452 {
7453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7454 }
7455 return resultobj;
7456 fail:
7457 return NULL;
7458 }
7459
7460
7461 static PyObject *_wrap_Region_SubtractRect(PyObject *, PyObject *args, PyObject *kwargs) {
7462 PyObject *resultobj;
7463 wxRegion *arg1 = (wxRegion *) 0 ;
7464 wxRect *arg2 = 0 ;
7465 bool result;
7466 wxRect temp2 ;
7467 PyObject * obj0 = 0 ;
7468 PyObject * obj1 = 0 ;
7469 char *kwnames[] = {
7470 (char *) "self",(char *) "rect", NULL
7471 };
7472
7473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRect",kwnames,&obj0,&obj1)) goto fail;
7474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7475 if (SWIG_arg_fail(1)) SWIG_fail;
7476 {
7477 arg2 = &temp2;
7478 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7479 }
7480 {
7481 PyThreadState* __tstate = wxPyBeginAllowThreads();
7482 result = (bool)(arg1)->Subtract((wxRect const &)*arg2);
7483
7484 wxPyEndAllowThreads(__tstate);
7485 if (PyErr_Occurred()) SWIG_fail;
7486 }
7487 {
7488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7489 }
7490 return resultobj;
7491 fail:
7492 return NULL;
7493 }
7494
7495
7496 static PyObject *_wrap_Region_SubtractRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7497 PyObject *resultobj;
7498 wxRegion *arg1 = (wxRegion *) 0 ;
7499 wxRegion *arg2 = 0 ;
7500 bool result;
7501 PyObject * obj0 = 0 ;
7502 PyObject * obj1 = 0 ;
7503 char *kwnames[] = {
7504 (char *) "self",(char *) "region", NULL
7505 };
7506
7507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRegion",kwnames,&obj0,&obj1)) goto fail;
7508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7509 if (SWIG_arg_fail(1)) SWIG_fail;
7510 {
7511 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7512 if (SWIG_arg_fail(2)) SWIG_fail;
7513 if (arg2 == NULL) {
7514 SWIG_null_ref("wxRegion");
7515 }
7516 if (SWIG_arg_fail(2)) SWIG_fail;
7517 }
7518 {
7519 PyThreadState* __tstate = wxPyBeginAllowThreads();
7520 result = (bool)(arg1)->Subtract((wxRegion const &)*arg2);
7521
7522 wxPyEndAllowThreads(__tstate);
7523 if (PyErr_Occurred()) SWIG_fail;
7524 }
7525 {
7526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7527 }
7528 return resultobj;
7529 fail:
7530 return NULL;
7531 }
7532
7533
7534 static PyObject *_wrap_Region_Xor(PyObject *, PyObject *args, PyObject *kwargs) {
7535 PyObject *resultobj;
7536 wxRegion *arg1 = (wxRegion *) 0 ;
7537 int arg2 ;
7538 int arg3 ;
7539 int arg4 ;
7540 int arg5 ;
7541 bool result;
7542 PyObject * obj0 = 0 ;
7543 PyObject * obj1 = 0 ;
7544 PyObject * obj2 = 0 ;
7545 PyObject * obj3 = 0 ;
7546 PyObject * obj4 = 0 ;
7547 char *kwnames[] = {
7548 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7549 };
7550
7551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Xor",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7553 if (SWIG_arg_fail(1)) SWIG_fail;
7554 {
7555 arg2 = (int)(SWIG_As_int(obj1));
7556 if (SWIG_arg_fail(2)) SWIG_fail;
7557 }
7558 {
7559 arg3 = (int)(SWIG_As_int(obj2));
7560 if (SWIG_arg_fail(3)) SWIG_fail;
7561 }
7562 {
7563 arg4 = (int)(SWIG_As_int(obj3));
7564 if (SWIG_arg_fail(4)) SWIG_fail;
7565 }
7566 {
7567 arg5 = (int)(SWIG_As_int(obj4));
7568 if (SWIG_arg_fail(5)) SWIG_fail;
7569 }
7570 {
7571 PyThreadState* __tstate = wxPyBeginAllowThreads();
7572 result = (bool)(arg1)->Xor(arg2,arg3,arg4,arg5);
7573
7574 wxPyEndAllowThreads(__tstate);
7575 if (PyErr_Occurred()) SWIG_fail;
7576 }
7577 {
7578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7579 }
7580 return resultobj;
7581 fail:
7582 return NULL;
7583 }
7584
7585
7586 static PyObject *_wrap_Region_XorRect(PyObject *, PyObject *args, PyObject *kwargs) {
7587 PyObject *resultobj;
7588 wxRegion *arg1 = (wxRegion *) 0 ;
7589 wxRect *arg2 = 0 ;
7590 bool result;
7591 wxRect temp2 ;
7592 PyObject * obj0 = 0 ;
7593 PyObject * obj1 = 0 ;
7594 char *kwnames[] = {
7595 (char *) "self",(char *) "rect", NULL
7596 };
7597
7598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRect",kwnames,&obj0,&obj1)) goto fail;
7599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7600 if (SWIG_arg_fail(1)) SWIG_fail;
7601 {
7602 arg2 = &temp2;
7603 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7604 }
7605 {
7606 PyThreadState* __tstate = wxPyBeginAllowThreads();
7607 result = (bool)(arg1)->Xor((wxRect const &)*arg2);
7608
7609 wxPyEndAllowThreads(__tstate);
7610 if (PyErr_Occurred()) SWIG_fail;
7611 }
7612 {
7613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7614 }
7615 return resultobj;
7616 fail:
7617 return NULL;
7618 }
7619
7620
7621 static PyObject *_wrap_Region_XorRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7622 PyObject *resultobj;
7623 wxRegion *arg1 = (wxRegion *) 0 ;
7624 wxRegion *arg2 = 0 ;
7625 bool result;
7626 PyObject * obj0 = 0 ;
7627 PyObject * obj1 = 0 ;
7628 char *kwnames[] = {
7629 (char *) "self",(char *) "region", NULL
7630 };
7631
7632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRegion",kwnames,&obj0,&obj1)) goto fail;
7633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7634 if (SWIG_arg_fail(1)) SWIG_fail;
7635 {
7636 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7637 if (SWIG_arg_fail(2)) SWIG_fail;
7638 if (arg2 == NULL) {
7639 SWIG_null_ref("wxRegion");
7640 }
7641 if (SWIG_arg_fail(2)) SWIG_fail;
7642 }
7643 {
7644 PyThreadState* __tstate = wxPyBeginAllowThreads();
7645 result = (bool)(arg1)->Xor((wxRegion const &)*arg2);
7646
7647 wxPyEndAllowThreads(__tstate);
7648 if (PyErr_Occurred()) SWIG_fail;
7649 }
7650 {
7651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7652 }
7653 return resultobj;
7654 fail:
7655 return NULL;
7656 }
7657
7658
7659 static PyObject *_wrap_Region_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7660 PyObject *resultobj;
7661 wxRegion *arg1 = (wxRegion *) 0 ;
7662 SwigValueWrapper<wxBitmap > result;
7663 PyObject * obj0 = 0 ;
7664 char *kwnames[] = {
7665 (char *) "self", NULL
7666 };
7667
7668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_ConvertToBitmap",kwnames,&obj0)) goto fail;
7669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7670 if (SWIG_arg_fail(1)) SWIG_fail;
7671 {
7672 PyThreadState* __tstate = wxPyBeginAllowThreads();
7673 result = (arg1)->ConvertToBitmap();
7674
7675 wxPyEndAllowThreads(__tstate);
7676 if (PyErr_Occurred()) SWIG_fail;
7677 }
7678 {
7679 wxBitmap * resultptr;
7680 resultptr = new wxBitmap((wxBitmap &)(result));
7681 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
7682 }
7683 return resultobj;
7684 fail:
7685 return NULL;
7686 }
7687
7688
7689 static PyObject *_wrap_Region_UnionBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7690 PyObject *resultobj;
7691 wxRegion *arg1 = (wxRegion *) 0 ;
7692 wxBitmap *arg2 = 0 ;
7693 bool result;
7694 PyObject * obj0 = 0 ;
7695 PyObject * obj1 = 0 ;
7696 char *kwnames[] = {
7697 (char *) "self",(char *) "bmp", NULL
7698 };
7699
7700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionBitmap",kwnames,&obj0,&obj1)) goto fail;
7701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7702 if (SWIG_arg_fail(1)) SWIG_fail;
7703 {
7704 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7705 if (SWIG_arg_fail(2)) SWIG_fail;
7706 if (arg2 == NULL) {
7707 SWIG_null_ref("wxBitmap");
7708 }
7709 if (SWIG_arg_fail(2)) SWIG_fail;
7710 }
7711 {
7712 PyThreadState* __tstate = wxPyBeginAllowThreads();
7713 result = (bool)(arg1)->Union((wxBitmap const &)*arg2);
7714
7715 wxPyEndAllowThreads(__tstate);
7716 if (PyErr_Occurred()) SWIG_fail;
7717 }
7718 {
7719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7720 }
7721 return resultobj;
7722 fail:
7723 return NULL;
7724 }
7725
7726
7727 static PyObject *_wrap_Region_UnionBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
7728 PyObject *resultobj;
7729 wxRegion *arg1 = (wxRegion *) 0 ;
7730 wxBitmap *arg2 = 0 ;
7731 wxColour *arg3 = 0 ;
7732 int arg4 = (int) 0 ;
7733 bool result;
7734 wxColour temp3 ;
7735 PyObject * obj0 = 0 ;
7736 PyObject * obj1 = 0 ;
7737 PyObject * obj2 = 0 ;
7738 PyObject * obj3 = 0 ;
7739 char *kwnames[] = {
7740 (char *) "self",(char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
7741 };
7742
7743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Region_UnionBitmapColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7745 if (SWIG_arg_fail(1)) SWIG_fail;
7746 {
7747 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7748 if (SWIG_arg_fail(2)) SWIG_fail;
7749 if (arg2 == NULL) {
7750 SWIG_null_ref("wxBitmap");
7751 }
7752 if (SWIG_arg_fail(2)) SWIG_fail;
7753 }
7754 {
7755 arg3 = &temp3;
7756 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
7757 }
7758 if (obj3) {
7759 {
7760 arg4 = (int)(SWIG_As_int(obj3));
7761 if (SWIG_arg_fail(4)) SWIG_fail;
7762 }
7763 }
7764 {
7765 PyThreadState* __tstate = wxPyBeginAllowThreads();
7766 result = (bool)(arg1)->Union((wxBitmap const &)*arg2,(wxColour const &)*arg3,arg4);
7767
7768 wxPyEndAllowThreads(__tstate);
7769 if (PyErr_Occurred()) SWIG_fail;
7770 }
7771 {
7772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7773 }
7774 return resultobj;
7775 fail:
7776 return NULL;
7777 }
7778
7779
7780 static PyObject * Region_swigregister(PyObject *, PyObject *args) {
7781 PyObject *obj;
7782 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7783 SWIG_TypeClientData(SWIGTYPE_p_wxRegion, obj);
7784 Py_INCREF(obj);
7785 return Py_BuildValue((char *)"");
7786 }
7787 static PyObject *_wrap_new_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7788 PyObject *resultobj;
7789 wxRegion *arg1 = 0 ;
7790 wxRegionIterator *result;
7791 PyObject * obj0 = 0 ;
7792 char *kwnames[] = {
7793 (char *) "region", NULL
7794 };
7795
7796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionIterator",kwnames,&obj0)) goto fail;
7797 {
7798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7799 if (SWIG_arg_fail(1)) SWIG_fail;
7800 if (arg1 == NULL) {
7801 SWIG_null_ref("wxRegion");
7802 }
7803 if (SWIG_arg_fail(1)) SWIG_fail;
7804 }
7805 {
7806 if (!wxPyCheckForApp()) SWIG_fail;
7807 PyThreadState* __tstate = wxPyBeginAllowThreads();
7808 result = (wxRegionIterator *)new wxRegionIterator((wxRegion const &)*arg1);
7809
7810 wxPyEndAllowThreads(__tstate);
7811 if (PyErr_Occurred()) SWIG_fail;
7812 }
7813 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegionIterator, 1);
7814 return resultobj;
7815 fail:
7816 return NULL;
7817 }
7818
7819
7820 static PyObject *_wrap_delete_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7821 PyObject *resultobj;
7822 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7823 PyObject * obj0 = 0 ;
7824 char *kwnames[] = {
7825 (char *) "self", NULL
7826 };
7827
7828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RegionIterator",kwnames,&obj0)) goto fail;
7829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7830 if (SWIG_arg_fail(1)) SWIG_fail;
7831 {
7832 PyThreadState* __tstate = wxPyBeginAllowThreads();
7833 delete arg1;
7834
7835 wxPyEndAllowThreads(__tstate);
7836 if (PyErr_Occurred()) SWIG_fail;
7837 }
7838 Py_INCREF(Py_None); resultobj = Py_None;
7839 return resultobj;
7840 fail:
7841 return NULL;
7842 }
7843
7844
7845 static PyObject *_wrap_RegionIterator_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
7846 PyObject *resultobj;
7847 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7848 int result;
7849 PyObject * obj0 = 0 ;
7850 char *kwnames[] = {
7851 (char *) "self", NULL
7852 };
7853
7854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetX",kwnames,&obj0)) goto fail;
7855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7856 if (SWIG_arg_fail(1)) SWIG_fail;
7857 {
7858 PyThreadState* __tstate = wxPyBeginAllowThreads();
7859 result = (int)(arg1)->GetX();
7860
7861 wxPyEndAllowThreads(__tstate);
7862 if (PyErr_Occurred()) SWIG_fail;
7863 }
7864 {
7865 resultobj = SWIG_From_int((int)(result));
7866 }
7867 return resultobj;
7868 fail:
7869 return NULL;
7870 }
7871
7872
7873 static PyObject *_wrap_RegionIterator_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
7874 PyObject *resultobj;
7875 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7876 int result;
7877 PyObject * obj0 = 0 ;
7878 char *kwnames[] = {
7879 (char *) "self", NULL
7880 };
7881
7882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetY",kwnames,&obj0)) goto fail;
7883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7884 if (SWIG_arg_fail(1)) SWIG_fail;
7885 {
7886 PyThreadState* __tstate = wxPyBeginAllowThreads();
7887 result = (int)(arg1)->GetY();
7888
7889 wxPyEndAllowThreads(__tstate);
7890 if (PyErr_Occurred()) SWIG_fail;
7891 }
7892 {
7893 resultobj = SWIG_From_int((int)(result));
7894 }
7895 return resultobj;
7896 fail:
7897 return NULL;
7898 }
7899
7900
7901 static PyObject *_wrap_RegionIterator_GetW(PyObject *, PyObject *args, PyObject *kwargs) {
7902 PyObject *resultobj;
7903 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7904 int result;
7905 PyObject * obj0 = 0 ;
7906 char *kwnames[] = {
7907 (char *) "self", NULL
7908 };
7909
7910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetW",kwnames,&obj0)) goto fail;
7911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7912 if (SWIG_arg_fail(1)) SWIG_fail;
7913 {
7914 PyThreadState* __tstate = wxPyBeginAllowThreads();
7915 result = (int)(arg1)->GetW();
7916
7917 wxPyEndAllowThreads(__tstate);
7918 if (PyErr_Occurred()) SWIG_fail;
7919 }
7920 {
7921 resultobj = SWIG_From_int((int)(result));
7922 }
7923 return resultobj;
7924 fail:
7925 return NULL;
7926 }
7927
7928
7929 static PyObject *_wrap_RegionIterator_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
7930 PyObject *resultobj;
7931 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7932 int result;
7933 PyObject * obj0 = 0 ;
7934 char *kwnames[] = {
7935 (char *) "self", NULL
7936 };
7937
7938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetWidth",kwnames,&obj0)) goto fail;
7939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7940 if (SWIG_arg_fail(1)) SWIG_fail;
7941 {
7942 PyThreadState* __tstate = wxPyBeginAllowThreads();
7943 result = (int)(arg1)->GetWidth();
7944
7945 wxPyEndAllowThreads(__tstate);
7946 if (PyErr_Occurred()) SWIG_fail;
7947 }
7948 {
7949 resultobj = SWIG_From_int((int)(result));
7950 }
7951 return resultobj;
7952 fail:
7953 return NULL;
7954 }
7955
7956
7957 static PyObject *_wrap_RegionIterator_GetH(PyObject *, PyObject *args, PyObject *kwargs) {
7958 PyObject *resultobj;
7959 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7960 int result;
7961 PyObject * obj0 = 0 ;
7962 char *kwnames[] = {
7963 (char *) "self", NULL
7964 };
7965
7966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetH",kwnames,&obj0)) goto fail;
7967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7968 if (SWIG_arg_fail(1)) SWIG_fail;
7969 {
7970 PyThreadState* __tstate = wxPyBeginAllowThreads();
7971 result = (int)(arg1)->GetH();
7972
7973 wxPyEndAllowThreads(__tstate);
7974 if (PyErr_Occurred()) SWIG_fail;
7975 }
7976 {
7977 resultobj = SWIG_From_int((int)(result));
7978 }
7979 return resultobj;
7980 fail:
7981 return NULL;
7982 }
7983
7984
7985 static PyObject *_wrap_RegionIterator_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
7986 PyObject *resultobj;
7987 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7988 int result;
7989 PyObject * obj0 = 0 ;
7990 char *kwnames[] = {
7991 (char *) "self", NULL
7992 };
7993
7994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetHeight",kwnames,&obj0)) goto fail;
7995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7996 if (SWIG_arg_fail(1)) SWIG_fail;
7997 {
7998 PyThreadState* __tstate = wxPyBeginAllowThreads();
7999 result = (int)(arg1)->GetHeight();
8000
8001 wxPyEndAllowThreads(__tstate);
8002 if (PyErr_Occurred()) SWIG_fail;
8003 }
8004 {
8005 resultobj = SWIG_From_int((int)(result));
8006 }
8007 return resultobj;
8008 fail:
8009 return NULL;
8010 }
8011
8012
8013 static PyObject *_wrap_RegionIterator_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
8014 PyObject *resultobj;
8015 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8016 wxRect result;
8017 PyObject * obj0 = 0 ;
8018 char *kwnames[] = {
8019 (char *) "self", NULL
8020 };
8021
8022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetRect",kwnames,&obj0)) goto fail;
8023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8024 if (SWIG_arg_fail(1)) SWIG_fail;
8025 {
8026 PyThreadState* __tstate = wxPyBeginAllowThreads();
8027 result = (arg1)->GetRect();
8028
8029 wxPyEndAllowThreads(__tstate);
8030 if (PyErr_Occurred()) SWIG_fail;
8031 }
8032 {
8033 wxRect * resultptr;
8034 resultptr = new wxRect((wxRect &)(result));
8035 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
8036 }
8037 return resultobj;
8038 fail:
8039 return NULL;
8040 }
8041
8042
8043 static PyObject *_wrap_RegionIterator_HaveRects(PyObject *, PyObject *args, PyObject *kwargs) {
8044 PyObject *resultobj;
8045 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8046 bool result;
8047 PyObject * obj0 = 0 ;
8048 char *kwnames[] = {
8049 (char *) "self", NULL
8050 };
8051
8052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_HaveRects",kwnames,&obj0)) goto fail;
8053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8054 if (SWIG_arg_fail(1)) SWIG_fail;
8055 {
8056 PyThreadState* __tstate = wxPyBeginAllowThreads();
8057 result = (bool)(arg1)->HaveRects();
8058
8059 wxPyEndAllowThreads(__tstate);
8060 if (PyErr_Occurred()) SWIG_fail;
8061 }
8062 {
8063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8064 }
8065 return resultobj;
8066 fail:
8067 return NULL;
8068 }
8069
8070
8071 static PyObject *_wrap_RegionIterator_Reset(PyObject *, PyObject *args, PyObject *kwargs) {
8072 PyObject *resultobj;
8073 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8074 PyObject * obj0 = 0 ;
8075 char *kwnames[] = {
8076 (char *) "self", NULL
8077 };
8078
8079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Reset",kwnames,&obj0)) goto fail;
8080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8081 if (SWIG_arg_fail(1)) SWIG_fail;
8082 {
8083 PyThreadState* __tstate = wxPyBeginAllowThreads();
8084 (arg1)->Reset();
8085
8086 wxPyEndAllowThreads(__tstate);
8087 if (PyErr_Occurred()) SWIG_fail;
8088 }
8089 Py_INCREF(Py_None); resultobj = Py_None;
8090 return resultobj;
8091 fail:
8092 return NULL;
8093 }
8094
8095
8096 static PyObject *_wrap_RegionIterator_Next(PyObject *, PyObject *args, PyObject *kwargs) {
8097 PyObject *resultobj;
8098 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8099 PyObject * obj0 = 0 ;
8100 char *kwnames[] = {
8101 (char *) "self", NULL
8102 };
8103
8104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Next",kwnames,&obj0)) goto fail;
8105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8106 if (SWIG_arg_fail(1)) SWIG_fail;
8107 {
8108 PyThreadState* __tstate = wxPyBeginAllowThreads();
8109 wxRegionIterator_Next(arg1);
8110
8111 wxPyEndAllowThreads(__tstate);
8112 if (PyErr_Occurred()) SWIG_fail;
8113 }
8114 Py_INCREF(Py_None); resultobj = Py_None;
8115 return resultobj;
8116 fail:
8117 return NULL;
8118 }
8119
8120
8121 static PyObject *_wrap_RegionIterator___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
8122 PyObject *resultobj;
8123 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8124 bool result;
8125 PyObject * obj0 = 0 ;
8126 char *kwnames[] = {
8127 (char *) "self", NULL
8128 };
8129
8130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator___nonzero__",kwnames,&obj0)) goto fail;
8131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8132 if (SWIG_arg_fail(1)) SWIG_fail;
8133 {
8134 PyThreadState* __tstate = wxPyBeginAllowThreads();
8135 result = (bool)wxRegionIterator___nonzero__(arg1);
8136
8137 wxPyEndAllowThreads(__tstate);
8138 if (PyErr_Occurred()) SWIG_fail;
8139 }
8140 {
8141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8142 }
8143 return resultobj;
8144 fail:
8145 return NULL;
8146 }
8147
8148
8149 static PyObject * RegionIterator_swigregister(PyObject *, PyObject *args) {
8150 PyObject *obj;
8151 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8152 SWIG_TypeClientData(SWIGTYPE_p_wxRegionIterator, obj);
8153 Py_INCREF(obj);
8154 return Py_BuildValue((char *)"");
8155 }
8156 static PyObject *_wrap_new_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8157 PyObject *resultobj;
8158 wxNativeFontInfo *result;
8159 char *kwnames[] = {
8160 NULL
8161 };
8162
8163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeFontInfo",kwnames)) goto fail;
8164 {
8165 PyThreadState* __tstate = wxPyBeginAllowThreads();
8166 result = (wxNativeFontInfo *)new wxNativeFontInfo();
8167
8168 wxPyEndAllowThreads(__tstate);
8169 if (PyErr_Occurred()) SWIG_fail;
8170 }
8171 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 1);
8172 return resultobj;
8173 fail:
8174 return NULL;
8175 }
8176
8177
8178 static PyObject *_wrap_delete_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8179 PyObject *resultobj;
8180 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8181 PyObject * obj0 = 0 ;
8182 char *kwnames[] = {
8183 (char *) "self", NULL
8184 };
8185
8186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeFontInfo",kwnames,&obj0)) goto fail;
8187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8188 if (SWIG_arg_fail(1)) SWIG_fail;
8189 {
8190 PyThreadState* __tstate = wxPyBeginAllowThreads();
8191 delete arg1;
8192
8193 wxPyEndAllowThreads(__tstate);
8194 if (PyErr_Occurred()) SWIG_fail;
8195 }
8196 Py_INCREF(Py_None); resultobj = Py_None;
8197 return resultobj;
8198 fail:
8199 return NULL;
8200 }
8201
8202
8203 static PyObject *_wrap_NativeFontInfo_Init(PyObject *, PyObject *args, PyObject *kwargs) {
8204 PyObject *resultobj;
8205 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8206 PyObject * obj0 = 0 ;
8207 char *kwnames[] = {
8208 (char *) "self", NULL
8209 };
8210
8211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_Init",kwnames,&obj0)) goto fail;
8212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8213 if (SWIG_arg_fail(1)) SWIG_fail;
8214 {
8215 PyThreadState* __tstate = wxPyBeginAllowThreads();
8216 (arg1)->Init();
8217
8218 wxPyEndAllowThreads(__tstate);
8219 if (PyErr_Occurred()) SWIG_fail;
8220 }
8221 Py_INCREF(Py_None); resultobj = Py_None;
8222 return resultobj;
8223 fail:
8224 return NULL;
8225 }
8226
8227
8228 static PyObject *_wrap_NativeFontInfo_InitFromFont(PyObject *, PyObject *args, PyObject *kwargs) {
8229 PyObject *resultobj;
8230 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8231 wxFont *arg2 = 0 ;
8232 PyObject * obj0 = 0 ;
8233 PyObject * obj1 = 0 ;
8234 char *kwnames[] = {
8235 (char *) "self",(char *) "font", NULL
8236 };
8237
8238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_InitFromFont",kwnames,&obj0,&obj1)) goto fail;
8239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8240 if (SWIG_arg_fail(1)) SWIG_fail;
8241 {
8242 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
8243 if (SWIG_arg_fail(2)) SWIG_fail;
8244 if (arg2 == NULL) {
8245 SWIG_null_ref("wxFont");
8246 }
8247 if (SWIG_arg_fail(2)) SWIG_fail;
8248 }
8249 {
8250 PyThreadState* __tstate = wxPyBeginAllowThreads();
8251 (arg1)->InitFromFont((wxFont const &)*arg2);
8252
8253 wxPyEndAllowThreads(__tstate);
8254 if (PyErr_Occurred()) SWIG_fail;
8255 }
8256 Py_INCREF(Py_None); resultobj = Py_None;
8257 return resultobj;
8258 fail:
8259 return NULL;
8260 }
8261
8262
8263 static PyObject *_wrap_NativeFontInfo_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
8264 PyObject *resultobj;
8265 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8266 int result;
8267 PyObject * obj0 = 0 ;
8268 char *kwnames[] = {
8269 (char *) "self", NULL
8270 };
8271
8272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetPointSize",kwnames,&obj0)) goto fail;
8273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8274 if (SWIG_arg_fail(1)) SWIG_fail;
8275 {
8276 PyThreadState* __tstate = wxPyBeginAllowThreads();
8277 result = (int)((wxNativeFontInfo const *)arg1)->GetPointSize();
8278
8279 wxPyEndAllowThreads(__tstate);
8280 if (PyErr_Occurred()) SWIG_fail;
8281 }
8282 {
8283 resultobj = SWIG_From_int((int)(result));
8284 }
8285 return resultobj;
8286 fail:
8287 return NULL;
8288 }
8289
8290
8291 static PyObject *_wrap_NativeFontInfo_GetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
8292 PyObject *resultobj;
8293 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8294 wxSize result;
8295 PyObject * obj0 = 0 ;
8296 char *kwnames[] = {
8297 (char *) "self", NULL
8298 };
8299
8300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetPixelSize",kwnames,&obj0)) goto fail;
8301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8302 if (SWIG_arg_fail(1)) SWIG_fail;
8303 {
8304 PyThreadState* __tstate = wxPyBeginAllowThreads();
8305 result = ((wxNativeFontInfo const *)arg1)->GetPixelSize();
8306
8307 wxPyEndAllowThreads(__tstate);
8308 if (PyErr_Occurred()) SWIG_fail;
8309 }
8310 {
8311 wxSize * resultptr;
8312 resultptr = new wxSize((wxSize &)(result));
8313 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
8314 }
8315 return resultobj;
8316 fail:
8317 return NULL;
8318 }
8319
8320
8321 static PyObject *_wrap_NativeFontInfo_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
8322 PyObject *resultobj;
8323 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8324 wxFontStyle result;
8325 PyObject * obj0 = 0 ;
8326 char *kwnames[] = {
8327 (char *) "self", NULL
8328 };
8329
8330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetStyle",kwnames,&obj0)) goto fail;
8331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8332 if (SWIG_arg_fail(1)) SWIG_fail;
8333 {
8334 PyThreadState* __tstate = wxPyBeginAllowThreads();
8335 result = (wxFontStyle)((wxNativeFontInfo const *)arg1)->GetStyle();
8336
8337 wxPyEndAllowThreads(__tstate);
8338 if (PyErr_Occurred()) SWIG_fail;
8339 }
8340 resultobj = SWIG_From_int((result));
8341 return resultobj;
8342 fail:
8343 return NULL;
8344 }
8345
8346
8347 static PyObject *_wrap_NativeFontInfo_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
8348 PyObject *resultobj;
8349 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8350 wxFontWeight result;
8351 PyObject * obj0 = 0 ;
8352 char *kwnames[] = {
8353 (char *) "self", NULL
8354 };
8355
8356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetWeight",kwnames,&obj0)) goto fail;
8357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8358 if (SWIG_arg_fail(1)) SWIG_fail;
8359 {
8360 PyThreadState* __tstate = wxPyBeginAllowThreads();
8361 result = (wxFontWeight)((wxNativeFontInfo const *)arg1)->GetWeight();
8362
8363 wxPyEndAllowThreads(__tstate);
8364 if (PyErr_Occurred()) SWIG_fail;
8365 }
8366 resultobj = SWIG_From_int((result));
8367 return resultobj;
8368 fail:
8369 return NULL;
8370 }
8371
8372
8373 static PyObject *_wrap_NativeFontInfo_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
8374 PyObject *resultobj;
8375 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8376 bool result;
8377 PyObject * obj0 = 0 ;
8378 char *kwnames[] = {
8379 (char *) "self", NULL
8380 };
8381
8382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetUnderlined",kwnames,&obj0)) goto fail;
8383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8384 if (SWIG_arg_fail(1)) SWIG_fail;
8385 {
8386 PyThreadState* __tstate = wxPyBeginAllowThreads();
8387 result = (bool)((wxNativeFontInfo const *)arg1)->GetUnderlined();
8388
8389 wxPyEndAllowThreads(__tstate);
8390 if (PyErr_Occurred()) SWIG_fail;
8391 }
8392 {
8393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8394 }
8395 return resultobj;
8396 fail:
8397 return NULL;
8398 }
8399
8400
8401 static PyObject *_wrap_NativeFontInfo_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
8402 PyObject *resultobj;
8403 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8404 wxString result;
8405 PyObject * obj0 = 0 ;
8406 char *kwnames[] = {
8407 (char *) "self", NULL
8408 };
8409
8410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFaceName",kwnames,&obj0)) goto fail;
8411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8412 if (SWIG_arg_fail(1)) SWIG_fail;
8413 {
8414 PyThreadState* __tstate = wxPyBeginAllowThreads();
8415 result = ((wxNativeFontInfo const *)arg1)->GetFaceName();
8416
8417 wxPyEndAllowThreads(__tstate);
8418 if (PyErr_Occurred()) SWIG_fail;
8419 }
8420 {
8421 #if wxUSE_UNICODE
8422 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8423 #else
8424 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8425 #endif
8426 }
8427 return resultobj;
8428 fail:
8429 return NULL;
8430 }
8431
8432
8433 static PyObject *_wrap_NativeFontInfo_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
8434 PyObject *resultobj;
8435 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8436 wxFontFamily result;
8437 PyObject * obj0 = 0 ;
8438 char *kwnames[] = {
8439 (char *) "self", NULL
8440 };
8441
8442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFamily",kwnames,&obj0)) goto fail;
8443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8444 if (SWIG_arg_fail(1)) SWIG_fail;
8445 {
8446 PyThreadState* __tstate = wxPyBeginAllowThreads();
8447 result = (wxFontFamily)((wxNativeFontInfo const *)arg1)->GetFamily();
8448
8449 wxPyEndAllowThreads(__tstate);
8450 if (PyErr_Occurred()) SWIG_fail;
8451 }
8452 resultobj = SWIG_From_int((result));
8453 return resultobj;
8454 fail:
8455 return NULL;
8456 }
8457
8458
8459 static PyObject *_wrap_NativeFontInfo_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8460 PyObject *resultobj;
8461 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8462 wxFontEncoding result;
8463 PyObject * obj0 = 0 ;
8464 char *kwnames[] = {
8465 (char *) "self", NULL
8466 };
8467
8468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetEncoding",kwnames,&obj0)) goto fail;
8469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8470 if (SWIG_arg_fail(1)) SWIG_fail;
8471 {
8472 PyThreadState* __tstate = wxPyBeginAllowThreads();
8473 result = (wxFontEncoding)((wxNativeFontInfo const *)arg1)->GetEncoding();
8474
8475 wxPyEndAllowThreads(__tstate);
8476 if (PyErr_Occurred()) SWIG_fail;
8477 }
8478 resultobj = SWIG_From_int((result));
8479 return resultobj;
8480 fail:
8481 return NULL;
8482 }
8483
8484
8485 static PyObject *_wrap_NativeFontInfo_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
8486 PyObject *resultobj;
8487 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8488 int arg2 ;
8489 PyObject * obj0 = 0 ;
8490 PyObject * obj1 = 0 ;
8491 char *kwnames[] = {
8492 (char *) "self",(char *) "pointsize", NULL
8493 };
8494
8495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
8496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8497 if (SWIG_arg_fail(1)) SWIG_fail;
8498 {
8499 arg2 = (int)(SWIG_As_int(obj1));
8500 if (SWIG_arg_fail(2)) SWIG_fail;
8501 }
8502 {
8503 PyThreadState* __tstate = wxPyBeginAllowThreads();
8504 (arg1)->SetPointSize(arg2);
8505
8506 wxPyEndAllowThreads(__tstate);
8507 if (PyErr_Occurred()) SWIG_fail;
8508 }
8509 Py_INCREF(Py_None); resultobj = Py_None;
8510 return resultobj;
8511 fail:
8512 return NULL;
8513 }
8514
8515
8516 static PyObject *_wrap_NativeFontInfo_SetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
8517 PyObject *resultobj;
8518 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8519 wxSize *arg2 = 0 ;
8520 wxSize temp2 ;
8521 PyObject * obj0 = 0 ;
8522 PyObject * obj1 = 0 ;
8523 char *kwnames[] = {
8524 (char *) "self",(char *) "pixelSize", NULL
8525 };
8526
8527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPixelSize",kwnames,&obj0,&obj1)) goto fail;
8528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8529 if (SWIG_arg_fail(1)) SWIG_fail;
8530 {
8531 arg2 = &temp2;
8532 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8533 }
8534 {
8535 PyThreadState* __tstate = wxPyBeginAllowThreads();
8536 (arg1)->SetPixelSize((wxSize const &)*arg2);
8537
8538 wxPyEndAllowThreads(__tstate);
8539 if (PyErr_Occurred()) SWIG_fail;
8540 }
8541 Py_INCREF(Py_None); resultobj = Py_None;
8542 return resultobj;
8543 fail:
8544 return NULL;
8545 }
8546
8547
8548 static PyObject *_wrap_NativeFontInfo_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
8549 PyObject *resultobj;
8550 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8551 wxFontStyle arg2 ;
8552 PyObject * obj0 = 0 ;
8553 PyObject * obj1 = 0 ;
8554 char *kwnames[] = {
8555 (char *) "self",(char *) "style", NULL
8556 };
8557
8558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetStyle",kwnames,&obj0,&obj1)) goto fail;
8559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8560 if (SWIG_arg_fail(1)) SWIG_fail;
8561 {
8562 arg2 = (wxFontStyle)(SWIG_As_int(obj1));
8563 if (SWIG_arg_fail(2)) SWIG_fail;
8564 }
8565 {
8566 PyThreadState* __tstate = wxPyBeginAllowThreads();
8567 (arg1)->SetStyle((wxFontStyle )arg2);
8568
8569 wxPyEndAllowThreads(__tstate);
8570 if (PyErr_Occurred()) SWIG_fail;
8571 }
8572 Py_INCREF(Py_None); resultobj = Py_None;
8573 return resultobj;
8574 fail:
8575 return NULL;
8576 }
8577
8578
8579 static PyObject *_wrap_NativeFontInfo_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
8580 PyObject *resultobj;
8581 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8582 wxFontWeight arg2 ;
8583 PyObject * obj0 = 0 ;
8584 PyObject * obj1 = 0 ;
8585 char *kwnames[] = {
8586 (char *) "self",(char *) "weight", NULL
8587 };
8588
8589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetWeight",kwnames,&obj0,&obj1)) goto fail;
8590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8591 if (SWIG_arg_fail(1)) SWIG_fail;
8592 {
8593 arg2 = (wxFontWeight)(SWIG_As_int(obj1));
8594 if (SWIG_arg_fail(2)) SWIG_fail;
8595 }
8596 {
8597 PyThreadState* __tstate = wxPyBeginAllowThreads();
8598 (arg1)->SetWeight((wxFontWeight )arg2);
8599
8600 wxPyEndAllowThreads(__tstate);
8601 if (PyErr_Occurred()) SWIG_fail;
8602 }
8603 Py_INCREF(Py_None); resultobj = Py_None;
8604 return resultobj;
8605 fail:
8606 return NULL;
8607 }
8608
8609
8610 static PyObject *_wrap_NativeFontInfo_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
8611 PyObject *resultobj;
8612 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8613 bool arg2 ;
8614 PyObject * obj0 = 0 ;
8615 PyObject * obj1 = 0 ;
8616 char *kwnames[] = {
8617 (char *) "self",(char *) "underlined", NULL
8618 };
8619
8620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
8621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8622 if (SWIG_arg_fail(1)) SWIG_fail;
8623 {
8624 arg2 = (bool)(SWIG_As_bool(obj1));
8625 if (SWIG_arg_fail(2)) SWIG_fail;
8626 }
8627 {
8628 PyThreadState* __tstate = wxPyBeginAllowThreads();
8629 (arg1)->SetUnderlined(arg2);
8630
8631 wxPyEndAllowThreads(__tstate);
8632 if (PyErr_Occurred()) SWIG_fail;
8633 }
8634 Py_INCREF(Py_None); resultobj = Py_None;
8635 return resultobj;
8636 fail:
8637 return NULL;
8638 }
8639
8640
8641 static PyObject *_wrap_NativeFontInfo_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
8642 PyObject *resultobj;
8643 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8644 wxString arg2 ;
8645 PyObject * obj0 = 0 ;
8646 PyObject * obj1 = 0 ;
8647 char *kwnames[] = {
8648 (char *) "self",(char *) "facename", NULL
8649 };
8650
8651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
8652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8653 if (SWIG_arg_fail(1)) SWIG_fail;
8654 {
8655 wxString* sptr = wxString_in_helper(obj1);
8656 if (sptr == NULL) SWIG_fail;
8657 arg2 = *sptr;
8658 delete sptr;
8659 }
8660 {
8661 PyThreadState* __tstate = wxPyBeginAllowThreads();
8662 (arg1)->SetFaceName(arg2);
8663
8664 wxPyEndAllowThreads(__tstate);
8665 if (PyErr_Occurred()) SWIG_fail;
8666 }
8667 Py_INCREF(Py_None); resultobj = Py_None;
8668 return resultobj;
8669 fail:
8670 return NULL;
8671 }
8672
8673
8674 static PyObject *_wrap_NativeFontInfo_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
8675 PyObject *resultobj;
8676 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8677 wxFontFamily arg2 ;
8678 PyObject * obj0 = 0 ;
8679 PyObject * obj1 = 0 ;
8680 char *kwnames[] = {
8681 (char *) "self",(char *) "family", NULL
8682 };
8683
8684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFamily",kwnames,&obj0,&obj1)) goto fail;
8685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8686 if (SWIG_arg_fail(1)) SWIG_fail;
8687 {
8688 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
8689 if (SWIG_arg_fail(2)) SWIG_fail;
8690 }
8691 {
8692 PyThreadState* __tstate = wxPyBeginAllowThreads();
8693 (arg1)->SetFamily((wxFontFamily )arg2);
8694
8695 wxPyEndAllowThreads(__tstate);
8696 if (PyErr_Occurred()) SWIG_fail;
8697 }
8698 Py_INCREF(Py_None); resultobj = Py_None;
8699 return resultobj;
8700 fail:
8701 return NULL;
8702 }
8703
8704
8705 static PyObject *_wrap_NativeFontInfo_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8706 PyObject *resultobj;
8707 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8708 wxFontEncoding arg2 ;
8709 PyObject * obj0 = 0 ;
8710 PyObject * obj1 = 0 ;
8711 char *kwnames[] = {
8712 (char *) "self",(char *) "encoding", NULL
8713 };
8714
8715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
8716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8717 if (SWIG_arg_fail(1)) SWIG_fail;
8718 {
8719 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8720 if (SWIG_arg_fail(2)) SWIG_fail;
8721 }
8722 {
8723 PyThreadState* __tstate = wxPyBeginAllowThreads();
8724 (arg1)->SetEncoding((wxFontEncoding )arg2);
8725
8726 wxPyEndAllowThreads(__tstate);
8727 if (PyErr_Occurred()) SWIG_fail;
8728 }
8729 Py_INCREF(Py_None); resultobj = Py_None;
8730 return resultobj;
8731 fail:
8732 return NULL;
8733 }
8734
8735
8736 static PyObject *_wrap_NativeFontInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8737 PyObject *resultobj;
8738 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8739 wxString *arg2 = 0 ;
8740 bool result;
8741 bool temp2 = false ;
8742 PyObject * obj0 = 0 ;
8743 PyObject * obj1 = 0 ;
8744 char *kwnames[] = {
8745 (char *) "self",(char *) "s", NULL
8746 };
8747
8748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8750 if (SWIG_arg_fail(1)) SWIG_fail;
8751 {
8752 arg2 = wxString_in_helper(obj1);
8753 if (arg2 == NULL) SWIG_fail;
8754 temp2 = true;
8755 }
8756 {
8757 PyThreadState* __tstate = wxPyBeginAllowThreads();
8758 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8759
8760 wxPyEndAllowThreads(__tstate);
8761 if (PyErr_Occurred()) SWIG_fail;
8762 }
8763 {
8764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8765 }
8766 {
8767 if (temp2)
8768 delete arg2;
8769 }
8770 return resultobj;
8771 fail:
8772 {
8773 if (temp2)
8774 delete arg2;
8775 }
8776 return NULL;
8777 }
8778
8779
8780 static PyObject *_wrap_NativeFontInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8781 PyObject *resultobj;
8782 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8783 wxString result;
8784 PyObject * obj0 = 0 ;
8785 char *kwnames[] = {
8786 (char *) "self", NULL
8787 };
8788
8789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToString",kwnames,&obj0)) goto fail;
8790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8791 if (SWIG_arg_fail(1)) SWIG_fail;
8792 {
8793 PyThreadState* __tstate = wxPyBeginAllowThreads();
8794 result = ((wxNativeFontInfo const *)arg1)->ToString();
8795
8796 wxPyEndAllowThreads(__tstate);
8797 if (PyErr_Occurred()) SWIG_fail;
8798 }
8799 {
8800 #if wxUSE_UNICODE
8801 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8802 #else
8803 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8804 #endif
8805 }
8806 return resultobj;
8807 fail:
8808 return NULL;
8809 }
8810
8811
8812 static PyObject *_wrap_NativeFontInfo___str__(PyObject *, PyObject *args, PyObject *kwargs) {
8813 PyObject *resultobj;
8814 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8815 wxString result;
8816 PyObject * obj0 = 0 ;
8817 char *kwnames[] = {
8818 (char *) "self", NULL
8819 };
8820
8821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo___str__",kwnames,&obj0)) goto fail;
8822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8823 if (SWIG_arg_fail(1)) SWIG_fail;
8824 {
8825 PyThreadState* __tstate = wxPyBeginAllowThreads();
8826 result = wxNativeFontInfo___str__(arg1);
8827
8828 wxPyEndAllowThreads(__tstate);
8829 if (PyErr_Occurred()) SWIG_fail;
8830 }
8831 {
8832 #if wxUSE_UNICODE
8833 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8834 #else
8835 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8836 #endif
8837 }
8838 return resultobj;
8839 fail:
8840 return NULL;
8841 }
8842
8843
8844 static PyObject *_wrap_NativeFontInfo_FromUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8845 PyObject *resultobj;
8846 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8847 wxString *arg2 = 0 ;
8848 bool result;
8849 bool temp2 = false ;
8850 PyObject * obj0 = 0 ;
8851 PyObject * obj1 = 0 ;
8852 char *kwnames[] = {
8853 (char *) "self",(char *) "s", NULL
8854 };
8855
8856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromUserString",kwnames,&obj0,&obj1)) goto fail;
8857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8858 if (SWIG_arg_fail(1)) SWIG_fail;
8859 {
8860 arg2 = wxString_in_helper(obj1);
8861 if (arg2 == NULL) SWIG_fail;
8862 temp2 = true;
8863 }
8864 {
8865 PyThreadState* __tstate = wxPyBeginAllowThreads();
8866 result = (bool)(arg1)->FromUserString((wxString const &)*arg2);
8867
8868 wxPyEndAllowThreads(__tstate);
8869 if (PyErr_Occurred()) SWIG_fail;
8870 }
8871 {
8872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8873 }
8874 {
8875 if (temp2)
8876 delete arg2;
8877 }
8878 return resultobj;
8879 fail:
8880 {
8881 if (temp2)
8882 delete arg2;
8883 }
8884 return NULL;
8885 }
8886
8887
8888 static PyObject *_wrap_NativeFontInfo_ToUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8889 PyObject *resultobj;
8890 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8891 wxString result;
8892 PyObject * obj0 = 0 ;
8893 char *kwnames[] = {
8894 (char *) "self", NULL
8895 };
8896
8897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToUserString",kwnames,&obj0)) goto fail;
8898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8899 if (SWIG_arg_fail(1)) SWIG_fail;
8900 {
8901 PyThreadState* __tstate = wxPyBeginAllowThreads();
8902 result = ((wxNativeFontInfo const *)arg1)->ToUserString();
8903
8904 wxPyEndAllowThreads(__tstate);
8905 if (PyErr_Occurred()) SWIG_fail;
8906 }
8907 {
8908 #if wxUSE_UNICODE
8909 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8910 #else
8911 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8912 #endif
8913 }
8914 return resultobj;
8915 fail:
8916 return NULL;
8917 }
8918
8919
8920 static PyObject * NativeFontInfo_swigregister(PyObject *, PyObject *args) {
8921 PyObject *obj;
8922 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8923 SWIG_TypeClientData(SWIGTYPE_p_wxNativeFontInfo, obj);
8924 Py_INCREF(obj);
8925 return Py_BuildValue((char *)"");
8926 }
8927 static PyObject *_wrap_NativeEncodingInfo_facename_set(PyObject *, PyObject *args, PyObject *kwargs) {
8928 PyObject *resultobj;
8929 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8930 wxString *arg2 = (wxString *) 0 ;
8931 bool temp2 = false ;
8932 PyObject * obj0 = 0 ;
8933 PyObject * obj1 = 0 ;
8934 char *kwnames[] = {
8935 (char *) "self",(char *) "facename", NULL
8936 };
8937
8938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_facename_set",kwnames,&obj0,&obj1)) goto fail;
8939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8940 if (SWIG_arg_fail(1)) SWIG_fail;
8941 {
8942 arg2 = wxString_in_helper(obj1);
8943 if (arg2 == NULL) SWIG_fail;
8944 temp2 = true;
8945 }
8946 if (arg1) (arg1)->facename = *arg2;
8947
8948 Py_INCREF(Py_None); resultobj = Py_None;
8949 {
8950 if (temp2)
8951 delete arg2;
8952 }
8953 return resultobj;
8954 fail:
8955 {
8956 if (temp2)
8957 delete arg2;
8958 }
8959 return NULL;
8960 }
8961
8962
8963 static PyObject *_wrap_NativeEncodingInfo_facename_get(PyObject *, PyObject *args, PyObject *kwargs) {
8964 PyObject *resultobj;
8965 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8966 wxString *result;
8967 PyObject * obj0 = 0 ;
8968 char *kwnames[] = {
8969 (char *) "self", NULL
8970 };
8971
8972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_facename_get",kwnames,&obj0)) goto fail;
8973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8974 if (SWIG_arg_fail(1)) SWIG_fail;
8975 result = (wxString *)& ((arg1)->facename);
8976
8977 {
8978 #if wxUSE_UNICODE
8979 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8980 #else
8981 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8982 #endif
8983 }
8984 return resultobj;
8985 fail:
8986 return NULL;
8987 }
8988
8989
8990 static PyObject *_wrap_NativeEncodingInfo_encoding_set(PyObject *, PyObject *args, PyObject *kwargs) {
8991 PyObject *resultobj;
8992 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8993 wxFontEncoding arg2 ;
8994 PyObject * obj0 = 0 ;
8995 PyObject * obj1 = 0 ;
8996 char *kwnames[] = {
8997 (char *) "self",(char *) "encoding", NULL
8998 };
8999
9000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_encoding_set",kwnames,&obj0,&obj1)) goto fail;
9001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9002 if (SWIG_arg_fail(1)) SWIG_fail;
9003 {
9004 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9005 if (SWIG_arg_fail(2)) SWIG_fail;
9006 }
9007 if (arg1) (arg1)->encoding = (wxFontEncoding )arg2;
9008
9009 Py_INCREF(Py_None); resultobj = Py_None;
9010 return resultobj;
9011 fail:
9012 return NULL;
9013 }
9014
9015
9016 static PyObject *_wrap_NativeEncodingInfo_encoding_get(PyObject *, PyObject *args, PyObject *kwargs) {
9017 PyObject *resultobj;
9018 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9019 wxFontEncoding result;
9020 PyObject * obj0 = 0 ;
9021 char *kwnames[] = {
9022 (char *) "self", NULL
9023 };
9024
9025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_encoding_get",kwnames,&obj0)) goto fail;
9026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9027 if (SWIG_arg_fail(1)) SWIG_fail;
9028 result = (wxFontEncoding) ((arg1)->encoding);
9029
9030 resultobj = SWIG_From_int((result));
9031 return resultobj;
9032 fail:
9033 return NULL;
9034 }
9035
9036
9037 static PyObject *_wrap_new_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9038 PyObject *resultobj;
9039 wxNativeEncodingInfo *result;
9040 char *kwnames[] = {
9041 NULL
9042 };
9043
9044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeEncodingInfo",kwnames)) goto fail;
9045 {
9046 PyThreadState* __tstate = wxPyBeginAllowThreads();
9047 result = (wxNativeEncodingInfo *)new wxNativeEncodingInfo();
9048
9049 wxPyEndAllowThreads(__tstate);
9050 if (PyErr_Occurred()) SWIG_fail;
9051 }
9052 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 1);
9053 return resultobj;
9054 fail:
9055 return NULL;
9056 }
9057
9058
9059 static PyObject *_wrap_delete_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9060 PyObject *resultobj;
9061 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9062 PyObject * obj0 = 0 ;
9063 char *kwnames[] = {
9064 (char *) "self", NULL
9065 };
9066
9067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeEncodingInfo",kwnames,&obj0)) goto fail;
9068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9069 if (SWIG_arg_fail(1)) SWIG_fail;
9070 {
9071 PyThreadState* __tstate = wxPyBeginAllowThreads();
9072 delete arg1;
9073
9074 wxPyEndAllowThreads(__tstate);
9075 if (PyErr_Occurred()) SWIG_fail;
9076 }
9077 Py_INCREF(Py_None); resultobj = Py_None;
9078 return resultobj;
9079 fail:
9080 return NULL;
9081 }
9082
9083
9084 static PyObject *_wrap_NativeEncodingInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
9085 PyObject *resultobj;
9086 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9087 wxString *arg2 = 0 ;
9088 bool result;
9089 bool temp2 = false ;
9090 PyObject * obj0 = 0 ;
9091 PyObject * obj1 = 0 ;
9092 char *kwnames[] = {
9093 (char *) "self",(char *) "s", NULL
9094 };
9095
9096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
9097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9098 if (SWIG_arg_fail(1)) SWIG_fail;
9099 {
9100 arg2 = wxString_in_helper(obj1);
9101 if (arg2 == NULL) SWIG_fail;
9102 temp2 = true;
9103 }
9104 {
9105 PyThreadState* __tstate = wxPyBeginAllowThreads();
9106 result = (bool)(arg1)->FromString((wxString const &)*arg2);
9107
9108 wxPyEndAllowThreads(__tstate);
9109 if (PyErr_Occurred()) SWIG_fail;
9110 }
9111 {
9112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9113 }
9114 {
9115 if (temp2)
9116 delete arg2;
9117 }
9118 return resultobj;
9119 fail:
9120 {
9121 if (temp2)
9122 delete arg2;
9123 }
9124 return NULL;
9125 }
9126
9127
9128 static PyObject *_wrap_NativeEncodingInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
9129 PyObject *resultobj;
9130 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9131 wxString result;
9132 PyObject * obj0 = 0 ;
9133 char *kwnames[] = {
9134 (char *) "self", NULL
9135 };
9136
9137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_ToString",kwnames,&obj0)) goto fail;
9138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9139 if (SWIG_arg_fail(1)) SWIG_fail;
9140 {
9141 PyThreadState* __tstate = wxPyBeginAllowThreads();
9142 result = ((wxNativeEncodingInfo const *)arg1)->ToString();
9143
9144 wxPyEndAllowThreads(__tstate);
9145 if (PyErr_Occurred()) SWIG_fail;
9146 }
9147 {
9148 #if wxUSE_UNICODE
9149 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9150 #else
9151 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9152 #endif
9153 }
9154 return resultobj;
9155 fail:
9156 return NULL;
9157 }
9158
9159
9160 static PyObject * NativeEncodingInfo_swigregister(PyObject *, PyObject *args) {
9161 PyObject *obj;
9162 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9163 SWIG_TypeClientData(SWIGTYPE_p_wxNativeEncodingInfo, obj);
9164 Py_INCREF(obj);
9165 return Py_BuildValue((char *)"");
9166 }
9167 static PyObject *_wrap_GetNativeFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9168 PyObject *resultobj;
9169 wxFontEncoding arg1 ;
9170 wxNativeEncodingInfo *result;
9171 PyObject * obj0 = 0 ;
9172 char *kwnames[] = {
9173 (char *) "encoding", NULL
9174 };
9175
9176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetNativeFontEncoding",kwnames,&obj0)) goto fail;
9177 {
9178 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
9179 if (SWIG_arg_fail(1)) SWIG_fail;
9180 }
9181 {
9182 PyThreadState* __tstate = wxPyBeginAllowThreads();
9183 result = (wxNativeEncodingInfo *)wxGetNativeFontEncoding((wxFontEncoding )arg1);
9184
9185 wxPyEndAllowThreads(__tstate);
9186 if (PyErr_Occurred()) SWIG_fail;
9187 }
9188 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 0);
9189 return resultobj;
9190 fail:
9191 return NULL;
9192 }
9193
9194
9195 static PyObject *_wrap_TestFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9196 PyObject *resultobj;
9197 wxNativeEncodingInfo *arg1 = 0 ;
9198 bool result;
9199 PyObject * obj0 = 0 ;
9200 char *kwnames[] = {
9201 (char *) "info", NULL
9202 };
9203
9204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TestFontEncoding",kwnames,&obj0)) goto fail;
9205 {
9206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9207 if (SWIG_arg_fail(1)) SWIG_fail;
9208 if (arg1 == NULL) {
9209 SWIG_null_ref("wxNativeEncodingInfo");
9210 }
9211 if (SWIG_arg_fail(1)) SWIG_fail;
9212 }
9213 {
9214 PyThreadState* __tstate = wxPyBeginAllowThreads();
9215 result = (bool)wxTestFontEncoding((wxNativeEncodingInfo const &)*arg1);
9216
9217 wxPyEndAllowThreads(__tstate);
9218 if (PyErr_Occurred()) SWIG_fail;
9219 }
9220 {
9221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9222 }
9223 return resultobj;
9224 fail:
9225 return NULL;
9226 }
9227
9228
9229 static PyObject *_wrap_new_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
9230 PyObject *resultobj;
9231 wxFontMapper *result;
9232 char *kwnames[] = {
9233 NULL
9234 };
9235
9236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontMapper",kwnames)) goto fail;
9237 {
9238 PyThreadState* __tstate = wxPyBeginAllowThreads();
9239 result = (wxFontMapper *)new wxFontMapper();
9240
9241 wxPyEndAllowThreads(__tstate);
9242 if (PyErr_Occurred()) SWIG_fail;
9243 }
9244 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 1);
9245 return resultobj;
9246 fail:
9247 return NULL;
9248 }
9249
9250
9251 static PyObject *_wrap_delete_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
9252 PyObject *resultobj;
9253 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9254 PyObject * obj0 = 0 ;
9255 char *kwnames[] = {
9256 (char *) "self", NULL
9257 };
9258
9259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontMapper",kwnames,&obj0)) goto fail;
9260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9261 if (SWIG_arg_fail(1)) SWIG_fail;
9262 {
9263 PyThreadState* __tstate = wxPyBeginAllowThreads();
9264 delete arg1;
9265
9266 wxPyEndAllowThreads(__tstate);
9267 if (PyErr_Occurred()) SWIG_fail;
9268 }
9269 Py_INCREF(Py_None); resultobj = Py_None;
9270 return resultobj;
9271 fail:
9272 return NULL;
9273 }
9274
9275
9276 static PyObject *_wrap_FontMapper_Get(PyObject *, PyObject *args, PyObject *kwargs) {
9277 PyObject *resultobj;
9278 wxFontMapper *result;
9279 char *kwnames[] = {
9280 NULL
9281 };
9282
9283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_Get",kwnames)) goto fail;
9284 {
9285 PyThreadState* __tstate = wxPyBeginAllowThreads();
9286 result = (wxFontMapper *)wxFontMapper::Get();
9287
9288 wxPyEndAllowThreads(__tstate);
9289 if (PyErr_Occurred()) SWIG_fail;
9290 }
9291 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
9292 return resultobj;
9293 fail:
9294 return NULL;
9295 }
9296
9297
9298 static PyObject *_wrap_FontMapper_Set(PyObject *, PyObject *args, PyObject *kwargs) {
9299 PyObject *resultobj;
9300 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9301 wxFontMapper *result;
9302 PyObject * obj0 = 0 ;
9303 char *kwnames[] = {
9304 (char *) "mapper", NULL
9305 };
9306
9307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_Set",kwnames,&obj0)) goto fail;
9308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9309 if (SWIG_arg_fail(1)) SWIG_fail;
9310 {
9311 PyThreadState* __tstate = wxPyBeginAllowThreads();
9312 result = (wxFontMapper *)wxFontMapper::Set(arg1);
9313
9314 wxPyEndAllowThreads(__tstate);
9315 if (PyErr_Occurred()) SWIG_fail;
9316 }
9317 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
9318 return resultobj;
9319 fail:
9320 return NULL;
9321 }
9322
9323
9324 static PyObject *_wrap_FontMapper_CharsetToEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9325 PyObject *resultobj;
9326 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9327 wxString *arg2 = 0 ;
9328 bool arg3 = (bool) true ;
9329 wxFontEncoding result;
9330 bool temp2 = false ;
9331 PyObject * obj0 = 0 ;
9332 PyObject * obj1 = 0 ;
9333 PyObject * obj2 = 0 ;
9334 char *kwnames[] = {
9335 (char *) "self",(char *) "charset",(char *) "interactive", NULL
9336 };
9337
9338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_CharsetToEncoding",kwnames,&obj0,&obj1,&obj2)) goto fail;
9339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9340 if (SWIG_arg_fail(1)) SWIG_fail;
9341 {
9342 arg2 = wxString_in_helper(obj1);
9343 if (arg2 == NULL) SWIG_fail;
9344 temp2 = true;
9345 }
9346 if (obj2) {
9347 {
9348 arg3 = (bool)(SWIG_As_bool(obj2));
9349 if (SWIG_arg_fail(3)) SWIG_fail;
9350 }
9351 }
9352 {
9353 PyThreadState* __tstate = wxPyBeginAllowThreads();
9354 result = (wxFontEncoding)(arg1)->CharsetToEncoding((wxString const &)*arg2,arg3);
9355
9356 wxPyEndAllowThreads(__tstate);
9357 if (PyErr_Occurred()) SWIG_fail;
9358 }
9359 resultobj = SWIG_From_int((result));
9360 {
9361 if (temp2)
9362 delete arg2;
9363 }
9364 return resultobj;
9365 fail:
9366 {
9367 if (temp2)
9368 delete arg2;
9369 }
9370 return NULL;
9371 }
9372
9373
9374 static PyObject *_wrap_FontMapper_GetSupportedEncodingsCount(PyObject *, PyObject *args, PyObject *kwargs) {
9375 PyObject *resultobj;
9376 size_t result;
9377 char *kwnames[] = {
9378 NULL
9379 };
9380
9381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetSupportedEncodingsCount",kwnames)) goto fail;
9382 {
9383 PyThreadState* __tstate = wxPyBeginAllowThreads();
9384 result = (size_t)wxFontMapper::GetSupportedEncodingsCount();
9385
9386 wxPyEndAllowThreads(__tstate);
9387 if (PyErr_Occurred()) SWIG_fail;
9388 }
9389 {
9390 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9391 }
9392 return resultobj;
9393 fail:
9394 return NULL;
9395 }
9396
9397
9398 static PyObject *_wrap_FontMapper_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9399 PyObject *resultobj;
9400 size_t arg1 ;
9401 wxFontEncoding result;
9402 PyObject * obj0 = 0 ;
9403 char *kwnames[] = {
9404 (char *) "n", NULL
9405 };
9406
9407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncoding",kwnames,&obj0)) goto fail;
9408 {
9409 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
9410 if (SWIG_arg_fail(1)) SWIG_fail;
9411 }
9412 {
9413 PyThreadState* __tstate = wxPyBeginAllowThreads();
9414 result = (wxFontEncoding)wxFontMapper::GetEncoding(arg1);
9415
9416 wxPyEndAllowThreads(__tstate);
9417 if (PyErr_Occurred()) SWIG_fail;
9418 }
9419 resultobj = SWIG_From_int((result));
9420 return resultobj;
9421 fail:
9422 return NULL;
9423 }
9424
9425
9426 static PyObject *_wrap_FontMapper_GetEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
9427 PyObject *resultobj;
9428 wxFontEncoding arg1 ;
9429 wxString result;
9430 PyObject * obj0 = 0 ;
9431 char *kwnames[] = {
9432 (char *) "encoding", NULL
9433 };
9434
9435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingName",kwnames,&obj0)) goto fail;
9436 {
9437 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
9438 if (SWIG_arg_fail(1)) SWIG_fail;
9439 }
9440 {
9441 PyThreadState* __tstate = wxPyBeginAllowThreads();
9442 result = wxFontMapper::GetEncodingName((wxFontEncoding )arg1);
9443
9444 wxPyEndAllowThreads(__tstate);
9445 if (PyErr_Occurred()) SWIG_fail;
9446 }
9447 {
9448 #if wxUSE_UNICODE
9449 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9450 #else
9451 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9452 #endif
9453 }
9454 return resultobj;
9455 fail:
9456 return NULL;
9457 }
9458
9459
9460 static PyObject *_wrap_FontMapper_GetEncodingDescription(PyObject *, PyObject *args, PyObject *kwargs) {
9461 PyObject *resultobj;
9462 wxFontEncoding arg1 ;
9463 wxString result;
9464 PyObject * obj0 = 0 ;
9465 char *kwnames[] = {
9466 (char *) "encoding", NULL
9467 };
9468
9469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingDescription",kwnames,&obj0)) goto fail;
9470 {
9471 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
9472 if (SWIG_arg_fail(1)) SWIG_fail;
9473 }
9474 {
9475 PyThreadState* __tstate = wxPyBeginAllowThreads();
9476 result = wxFontMapper::GetEncodingDescription((wxFontEncoding )arg1);
9477
9478 wxPyEndAllowThreads(__tstate);
9479 if (PyErr_Occurred()) SWIG_fail;
9480 }
9481 {
9482 #if wxUSE_UNICODE
9483 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9484 #else
9485 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9486 #endif
9487 }
9488 return resultobj;
9489 fail:
9490 return NULL;
9491 }
9492
9493
9494 static PyObject *_wrap_FontMapper_GetEncodingFromName(PyObject *, PyObject *args, PyObject *kwargs) {
9495 PyObject *resultobj;
9496 wxString *arg1 = 0 ;
9497 wxFontEncoding result;
9498 bool temp1 = false ;
9499 PyObject * obj0 = 0 ;
9500 char *kwnames[] = {
9501 (char *) "name", NULL
9502 };
9503
9504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingFromName",kwnames,&obj0)) goto fail;
9505 {
9506 arg1 = wxString_in_helper(obj0);
9507 if (arg1 == NULL) SWIG_fail;
9508 temp1 = true;
9509 }
9510 {
9511 PyThreadState* __tstate = wxPyBeginAllowThreads();
9512 result = (wxFontEncoding)wxFontMapper::GetEncodingFromName((wxString const &)*arg1);
9513
9514 wxPyEndAllowThreads(__tstate);
9515 if (PyErr_Occurred()) SWIG_fail;
9516 }
9517 resultobj = SWIG_From_int((result));
9518 {
9519 if (temp1)
9520 delete arg1;
9521 }
9522 return resultobj;
9523 fail:
9524 {
9525 if (temp1)
9526 delete arg1;
9527 }
9528 return NULL;
9529 }
9530
9531
9532 static PyObject *_wrap_FontMapper_SetConfig(PyObject *, PyObject *args, PyObject *kwargs) {
9533 PyObject *resultobj;
9534 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9535 wxConfigBase *arg2 = (wxConfigBase *) 0 ;
9536 PyObject * obj0 = 0 ;
9537 PyObject * obj1 = 0 ;
9538 char *kwnames[] = {
9539 (char *) "self",(char *) "config", NULL
9540 };
9541
9542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfig",kwnames,&obj0,&obj1)) goto fail;
9543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9544 if (SWIG_arg_fail(1)) SWIG_fail;
9545 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
9546 if (SWIG_arg_fail(2)) SWIG_fail;
9547 {
9548 PyThreadState* __tstate = wxPyBeginAllowThreads();
9549 (arg1)->SetConfig(arg2);
9550
9551 wxPyEndAllowThreads(__tstate);
9552 if (PyErr_Occurred()) SWIG_fail;
9553 }
9554 Py_INCREF(Py_None); resultobj = Py_None;
9555 return resultobj;
9556 fail:
9557 return NULL;
9558 }
9559
9560
9561 static PyObject *_wrap_FontMapper_SetConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
9562 PyObject *resultobj;
9563 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9564 wxString *arg2 = 0 ;
9565 bool temp2 = false ;
9566 PyObject * obj0 = 0 ;
9567 PyObject * obj1 = 0 ;
9568 char *kwnames[] = {
9569 (char *) "self",(char *) "prefix", NULL
9570 };
9571
9572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfigPath",kwnames,&obj0,&obj1)) goto fail;
9573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9574 if (SWIG_arg_fail(1)) SWIG_fail;
9575 {
9576 arg2 = wxString_in_helper(obj1);
9577 if (arg2 == NULL) SWIG_fail;
9578 temp2 = true;
9579 }
9580 {
9581 PyThreadState* __tstate = wxPyBeginAllowThreads();
9582 (arg1)->SetConfigPath((wxString const &)*arg2);
9583
9584 wxPyEndAllowThreads(__tstate);
9585 if (PyErr_Occurred()) SWIG_fail;
9586 }
9587 Py_INCREF(Py_None); resultobj = Py_None;
9588 {
9589 if (temp2)
9590 delete arg2;
9591 }
9592 return resultobj;
9593 fail:
9594 {
9595 if (temp2)
9596 delete arg2;
9597 }
9598 return NULL;
9599 }
9600
9601
9602 static PyObject *_wrap_FontMapper_GetDefaultConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
9603 PyObject *resultobj;
9604 wxString result;
9605 char *kwnames[] = {
9606 NULL
9607 };
9608
9609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetDefaultConfigPath",kwnames)) goto fail;
9610 {
9611 PyThreadState* __tstate = wxPyBeginAllowThreads();
9612 result = wxFontMapper::GetDefaultConfigPath();
9613
9614 wxPyEndAllowThreads(__tstate);
9615 if (PyErr_Occurred()) SWIG_fail;
9616 }
9617 {
9618 #if wxUSE_UNICODE
9619 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9620 #else
9621 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9622 #endif
9623 }
9624 return resultobj;
9625 fail:
9626 return NULL;
9627 }
9628
9629
9630 static PyObject *_wrap_FontMapper_GetAltForEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9631 PyObject *resultobj;
9632 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9633 wxFontEncoding arg2 ;
9634 wxString const &arg3_defvalue = wxPyEmptyString ;
9635 wxString *arg3 = (wxString *) &arg3_defvalue ;
9636 bool arg4 = (bool) true ;
9637 PyObject *result;
9638 bool temp3 = false ;
9639 PyObject * obj0 = 0 ;
9640 PyObject * obj1 = 0 ;
9641 PyObject * obj2 = 0 ;
9642 PyObject * obj3 = 0 ;
9643 char *kwnames[] = {
9644 (char *) "self",(char *) "encoding",(char *) "facename",(char *) "interactive", NULL
9645 };
9646
9647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:FontMapper_GetAltForEncoding",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9649 if (SWIG_arg_fail(1)) SWIG_fail;
9650 {
9651 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9652 if (SWIG_arg_fail(2)) SWIG_fail;
9653 }
9654 if (obj2) {
9655 {
9656 arg3 = wxString_in_helper(obj2);
9657 if (arg3 == NULL) SWIG_fail;
9658 temp3 = true;
9659 }
9660 }
9661 if (obj3) {
9662 {
9663 arg4 = (bool)(SWIG_As_bool(obj3));
9664 if (SWIG_arg_fail(4)) SWIG_fail;
9665 }
9666 }
9667 {
9668 PyThreadState* __tstate = wxPyBeginAllowThreads();
9669 result = (PyObject *)wxFontMapper_GetAltForEncoding(arg1,(wxFontEncoding )arg2,(wxString const &)*arg3,arg4);
9670
9671 wxPyEndAllowThreads(__tstate);
9672 if (PyErr_Occurred()) SWIG_fail;
9673 }
9674 resultobj = result;
9675 {
9676 if (temp3)
9677 delete arg3;
9678 }
9679 return resultobj;
9680 fail:
9681 {
9682 if (temp3)
9683 delete arg3;
9684 }
9685 return NULL;
9686 }
9687
9688
9689 static PyObject *_wrap_FontMapper_IsEncodingAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
9690 PyObject *resultobj;
9691 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9692 wxFontEncoding arg2 ;
9693 wxString const &arg3_defvalue = wxPyEmptyString ;
9694 wxString *arg3 = (wxString *) &arg3_defvalue ;
9695 bool result;
9696 bool temp3 = false ;
9697 PyObject * obj0 = 0 ;
9698 PyObject * obj1 = 0 ;
9699 PyObject * obj2 = 0 ;
9700 char *kwnames[] = {
9701 (char *) "self",(char *) "encoding",(char *) "facename", NULL
9702 };
9703
9704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_IsEncodingAvailable",kwnames,&obj0,&obj1,&obj2)) goto fail;
9705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9706 if (SWIG_arg_fail(1)) SWIG_fail;
9707 {
9708 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9709 if (SWIG_arg_fail(2)) SWIG_fail;
9710 }
9711 if (obj2) {
9712 {
9713 arg3 = wxString_in_helper(obj2);
9714 if (arg3 == NULL) SWIG_fail;
9715 temp3 = true;
9716 }
9717 }
9718 {
9719 PyThreadState* __tstate = wxPyBeginAllowThreads();
9720 result = (bool)(arg1)->IsEncodingAvailable((wxFontEncoding )arg2,(wxString const &)*arg3);
9721
9722 wxPyEndAllowThreads(__tstate);
9723 if (PyErr_Occurred()) SWIG_fail;
9724 }
9725 {
9726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9727 }
9728 {
9729 if (temp3)
9730 delete arg3;
9731 }
9732 return resultobj;
9733 fail:
9734 {
9735 if (temp3)
9736 delete arg3;
9737 }
9738 return NULL;
9739 }
9740
9741
9742 static PyObject *_wrap_FontMapper_SetDialogParent(PyObject *, PyObject *args, PyObject *kwargs) {
9743 PyObject *resultobj;
9744 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9745 wxWindow *arg2 = (wxWindow *) 0 ;
9746 PyObject * obj0 = 0 ;
9747 PyObject * obj1 = 0 ;
9748 char *kwnames[] = {
9749 (char *) "self",(char *) "parent", NULL
9750 };
9751
9752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogParent",kwnames,&obj0,&obj1)) goto fail;
9753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9754 if (SWIG_arg_fail(1)) SWIG_fail;
9755 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9756 if (SWIG_arg_fail(2)) SWIG_fail;
9757 {
9758 PyThreadState* __tstate = wxPyBeginAllowThreads();
9759 (arg1)->SetDialogParent(arg2);
9760
9761 wxPyEndAllowThreads(__tstate);
9762 if (PyErr_Occurred()) SWIG_fail;
9763 }
9764 Py_INCREF(Py_None); resultobj = Py_None;
9765 return resultobj;
9766 fail:
9767 return NULL;
9768 }
9769
9770
9771 static PyObject *_wrap_FontMapper_SetDialogTitle(PyObject *, PyObject *args, PyObject *kwargs) {
9772 PyObject *resultobj;
9773 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9774 wxString *arg2 = 0 ;
9775 bool temp2 = false ;
9776 PyObject * obj0 = 0 ;
9777 PyObject * obj1 = 0 ;
9778 char *kwnames[] = {
9779 (char *) "self",(char *) "title", NULL
9780 };
9781
9782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogTitle",kwnames,&obj0,&obj1)) goto fail;
9783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9784 if (SWIG_arg_fail(1)) SWIG_fail;
9785 {
9786 arg2 = wxString_in_helper(obj1);
9787 if (arg2 == NULL) SWIG_fail;
9788 temp2 = true;
9789 }
9790 {
9791 PyThreadState* __tstate = wxPyBeginAllowThreads();
9792 (arg1)->SetDialogTitle((wxString const &)*arg2);
9793
9794 wxPyEndAllowThreads(__tstate);
9795 if (PyErr_Occurred()) SWIG_fail;
9796 }
9797 Py_INCREF(Py_None); resultobj = Py_None;
9798 {
9799 if (temp2)
9800 delete arg2;
9801 }
9802 return resultobj;
9803 fail:
9804 {
9805 if (temp2)
9806 delete arg2;
9807 }
9808 return NULL;
9809 }
9810
9811
9812 static PyObject * FontMapper_swigregister(PyObject *, PyObject *args) {
9813 PyObject *obj;
9814 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9815 SWIG_TypeClientData(SWIGTYPE_p_wxFontMapper, obj);
9816 Py_INCREF(obj);
9817 return Py_BuildValue((char *)"");
9818 }
9819 static PyObject *_wrap_new_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9820 PyObject *resultobj;
9821 int arg1 ;
9822 int arg2 ;
9823 int arg3 ;
9824 int arg4 ;
9825 bool arg5 = (bool) false ;
9826 wxString const &arg6_defvalue = wxPyEmptyString ;
9827 wxString *arg6 = (wxString *) &arg6_defvalue ;
9828 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9829 wxFont *result;
9830 bool temp6 = false ;
9831 PyObject * obj0 = 0 ;
9832 PyObject * obj1 = 0 ;
9833 PyObject * obj2 = 0 ;
9834 PyObject * obj3 = 0 ;
9835 PyObject * obj4 = 0 ;
9836 PyObject * obj5 = 0 ;
9837 PyObject * obj6 = 0 ;
9838 char *kwnames[] = {
9839 (char *) "pointSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "face",(char *) "encoding", NULL
9840 };
9841
9842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_Font",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9843 {
9844 arg1 = (int)(SWIG_As_int(obj0));
9845 if (SWIG_arg_fail(1)) SWIG_fail;
9846 }
9847 {
9848 arg2 = (int)(SWIG_As_int(obj1));
9849 if (SWIG_arg_fail(2)) SWIG_fail;
9850 }
9851 {
9852 arg3 = (int)(SWIG_As_int(obj2));
9853 if (SWIG_arg_fail(3)) SWIG_fail;
9854 }
9855 {
9856 arg4 = (int)(SWIG_As_int(obj3));
9857 if (SWIG_arg_fail(4)) SWIG_fail;
9858 }
9859 if (obj4) {
9860 {
9861 arg5 = (bool)(SWIG_As_bool(obj4));
9862 if (SWIG_arg_fail(5)) SWIG_fail;
9863 }
9864 }
9865 if (obj5) {
9866 {
9867 arg6 = wxString_in_helper(obj5);
9868 if (arg6 == NULL) SWIG_fail;
9869 temp6 = true;
9870 }
9871 }
9872 if (obj6) {
9873 {
9874 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9875 if (SWIG_arg_fail(7)) SWIG_fail;
9876 }
9877 }
9878 {
9879 if (!wxPyCheckForApp()) SWIG_fail;
9880 PyThreadState* __tstate = wxPyBeginAllowThreads();
9881 result = (wxFont *)new wxFont(arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9882
9883 wxPyEndAllowThreads(__tstate);
9884 if (PyErr_Occurred()) SWIG_fail;
9885 }
9886 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9887 {
9888 if (temp6)
9889 delete arg6;
9890 }
9891 return resultobj;
9892 fail:
9893 {
9894 if (temp6)
9895 delete arg6;
9896 }
9897 return NULL;
9898 }
9899
9900
9901 static PyObject *_wrap_delete_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9902 PyObject *resultobj;
9903 wxFont *arg1 = (wxFont *) 0 ;
9904 PyObject * obj0 = 0 ;
9905 char *kwnames[] = {
9906 (char *) "self", NULL
9907 };
9908
9909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Font",kwnames,&obj0)) goto fail;
9910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9911 if (SWIG_arg_fail(1)) SWIG_fail;
9912 {
9913 PyThreadState* __tstate = wxPyBeginAllowThreads();
9914 delete arg1;
9915
9916 wxPyEndAllowThreads(__tstate);
9917 if (PyErr_Occurred()) SWIG_fail;
9918 }
9919 Py_INCREF(Py_None); resultobj = Py_None;
9920 return resultobj;
9921 fail:
9922 return NULL;
9923 }
9924
9925
9926 static PyObject *_wrap_new_FontFromNativeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9927 PyObject *resultobj;
9928 wxNativeFontInfo *arg1 = 0 ;
9929 wxFont *result;
9930 PyObject * obj0 = 0 ;
9931 char *kwnames[] = {
9932 (char *) "info", NULL
9933 };
9934
9935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfo",kwnames,&obj0)) goto fail;
9936 {
9937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
9938 if (SWIG_arg_fail(1)) SWIG_fail;
9939 if (arg1 == NULL) {
9940 SWIG_null_ref("wxNativeFontInfo");
9941 }
9942 if (SWIG_arg_fail(1)) SWIG_fail;
9943 }
9944 {
9945 if (!wxPyCheckForApp()) SWIG_fail;
9946 PyThreadState* __tstate = wxPyBeginAllowThreads();
9947 result = (wxFont *)new wxFont((wxNativeFontInfo const &)*arg1);
9948
9949 wxPyEndAllowThreads(__tstate);
9950 if (PyErr_Occurred()) SWIG_fail;
9951 }
9952 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9953 return resultobj;
9954 fail:
9955 return NULL;
9956 }
9957
9958
9959 static PyObject *_wrap_new_FontFromNativeInfoString(PyObject *, PyObject *args, PyObject *kwargs) {
9960 PyObject *resultobj;
9961 wxString *arg1 = 0 ;
9962 wxFont *result;
9963 bool temp1 = false ;
9964 PyObject * obj0 = 0 ;
9965 char *kwnames[] = {
9966 (char *) "info", NULL
9967 };
9968
9969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfoString",kwnames,&obj0)) goto fail;
9970 {
9971 arg1 = wxString_in_helper(obj0);
9972 if (arg1 == NULL) SWIG_fail;
9973 temp1 = true;
9974 }
9975 {
9976 if (!wxPyCheckForApp()) SWIG_fail;
9977 PyThreadState* __tstate = wxPyBeginAllowThreads();
9978 result = (wxFont *)new_wxFont((wxString const &)*arg1);
9979
9980 wxPyEndAllowThreads(__tstate);
9981 if (PyErr_Occurred()) SWIG_fail;
9982 }
9983 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9984 {
9985 if (temp1)
9986 delete arg1;
9987 }
9988 return resultobj;
9989 fail:
9990 {
9991 if (temp1)
9992 delete arg1;
9993 }
9994 return NULL;
9995 }
9996
9997
9998 static PyObject *_wrap_new_Font2(PyObject *, PyObject *args, PyObject *kwargs) {
9999 PyObject *resultobj;
10000 int arg1 ;
10001 wxFontFamily arg2 ;
10002 int arg3 = (int) wxFONTFLAG_DEFAULT ;
10003 wxString const &arg4_defvalue = wxPyEmptyString ;
10004 wxString *arg4 = (wxString *) &arg4_defvalue ;
10005 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
10006 wxFont *result;
10007 bool temp4 = false ;
10008 PyObject * obj0 = 0 ;
10009 PyObject * obj1 = 0 ;
10010 PyObject * obj2 = 0 ;
10011 PyObject * obj3 = 0 ;
10012 PyObject * obj4 = 0 ;
10013 char *kwnames[] = {
10014 (char *) "pointSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
10015 };
10016
10017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_Font2",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
10018 {
10019 arg1 = (int)(SWIG_As_int(obj0));
10020 if (SWIG_arg_fail(1)) SWIG_fail;
10021 }
10022 {
10023 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
10024 if (SWIG_arg_fail(2)) SWIG_fail;
10025 }
10026 if (obj2) {
10027 {
10028 arg3 = (int)(SWIG_As_int(obj2));
10029 if (SWIG_arg_fail(3)) SWIG_fail;
10030 }
10031 }
10032 if (obj3) {
10033 {
10034 arg4 = wxString_in_helper(obj3);
10035 if (arg4 == NULL) SWIG_fail;
10036 temp4 = true;
10037 }
10038 }
10039 if (obj4) {
10040 {
10041 arg5 = (wxFontEncoding)(SWIG_As_int(obj4));
10042 if (SWIG_arg_fail(5)) SWIG_fail;
10043 }
10044 }
10045 {
10046 if (!wxPyCheckForApp()) SWIG_fail;
10047 PyThreadState* __tstate = wxPyBeginAllowThreads();
10048 result = (wxFont *)new_wxFont(arg1,(wxFontFamily )arg2,arg3,(wxString const &)*arg4,(wxFontEncoding )arg5);
10049
10050 wxPyEndAllowThreads(__tstate);
10051 if (PyErr_Occurred()) SWIG_fail;
10052 }
10053 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
10054 {
10055 if (temp4)
10056 delete arg4;
10057 }
10058 return resultobj;
10059 fail:
10060 {
10061 if (temp4)
10062 delete arg4;
10063 }
10064 return NULL;
10065 }
10066
10067
10068 static PyObject *_wrap_new_FontFromPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10069 PyObject *resultobj;
10070 wxSize *arg1 = 0 ;
10071 int arg2 ;
10072 int arg3 ;
10073 int arg4 ;
10074 bool arg5 = (bool) false ;
10075 wxString const &arg6_defvalue = wxEmptyString ;
10076 wxString *arg6 = (wxString *) &arg6_defvalue ;
10077 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
10078 wxFont *result;
10079 wxSize temp1 ;
10080 bool temp6 = false ;
10081 PyObject * obj0 = 0 ;
10082 PyObject * obj1 = 0 ;
10083 PyObject * obj2 = 0 ;
10084 PyObject * obj3 = 0 ;
10085 PyObject * obj4 = 0 ;
10086 PyObject * obj5 = 0 ;
10087 PyObject * obj6 = 0 ;
10088 char *kwnames[] = {
10089 (char *) "pixelSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underlined",(char *) "face",(char *) "encoding", NULL
10090 };
10091
10092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_FontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
10093 {
10094 arg1 = &temp1;
10095 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
10096 }
10097 {
10098 arg2 = (int)(SWIG_As_int(obj1));
10099 if (SWIG_arg_fail(2)) SWIG_fail;
10100 }
10101 {
10102 arg3 = (int)(SWIG_As_int(obj2));
10103 if (SWIG_arg_fail(3)) SWIG_fail;
10104 }
10105 {
10106 arg4 = (int)(SWIG_As_int(obj3));
10107 if (SWIG_arg_fail(4)) SWIG_fail;
10108 }
10109 if (obj4) {
10110 {
10111 arg5 = (bool)(SWIG_As_bool(obj4));
10112 if (SWIG_arg_fail(5)) SWIG_fail;
10113 }
10114 }
10115 if (obj5) {
10116 {
10117 arg6 = wxString_in_helper(obj5);
10118 if (arg6 == NULL) SWIG_fail;
10119 temp6 = true;
10120 }
10121 }
10122 if (obj6) {
10123 {
10124 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
10125 if (SWIG_arg_fail(7)) SWIG_fail;
10126 }
10127 }
10128 {
10129 if (!wxPyCheckForApp()) SWIG_fail;
10130 PyThreadState* __tstate = wxPyBeginAllowThreads();
10131 result = (wxFont *)new_wxFont((wxSize const &)*arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
10132
10133 wxPyEndAllowThreads(__tstate);
10134 if (PyErr_Occurred()) SWIG_fail;
10135 }
10136 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
10137 {
10138 if (temp6)
10139 delete arg6;
10140 }
10141 return resultobj;
10142 fail:
10143 {
10144 if (temp6)
10145 delete arg6;
10146 }
10147 return NULL;
10148 }
10149
10150
10151 static PyObject *_wrap_Font_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
10152 PyObject *resultobj;
10153 wxFont *arg1 = (wxFont *) 0 ;
10154 bool result;
10155 PyObject * obj0 = 0 ;
10156 char *kwnames[] = {
10157 (char *) "self", NULL
10158 };
10159
10160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_Ok",kwnames,&obj0)) goto fail;
10161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10162 if (SWIG_arg_fail(1)) SWIG_fail;
10163 {
10164 PyThreadState* __tstate = wxPyBeginAllowThreads();
10165 result = (bool)((wxFont const *)arg1)->Ok();
10166
10167 wxPyEndAllowThreads(__tstate);
10168 if (PyErr_Occurred()) SWIG_fail;
10169 }
10170 {
10171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10172 }
10173 return resultobj;
10174 fail:
10175 return NULL;
10176 }
10177
10178
10179 static PyObject *_wrap_Font___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
10180 PyObject *resultobj;
10181 wxFont *arg1 = (wxFont *) 0 ;
10182 wxFont *arg2 = (wxFont *) 0 ;
10183 bool result;
10184 PyObject * obj0 = 0 ;
10185 PyObject * obj1 = 0 ;
10186 char *kwnames[] = {
10187 (char *) "self",(char *) "other", NULL
10188 };
10189
10190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___eq__",kwnames,&obj0,&obj1)) goto fail;
10191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10192 if (SWIG_arg_fail(1)) SWIG_fail;
10193 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10194 if (SWIG_arg_fail(2)) SWIG_fail;
10195 {
10196 PyThreadState* __tstate = wxPyBeginAllowThreads();
10197 result = (bool)wxFont___eq__(arg1,(wxFont const *)arg2);
10198
10199 wxPyEndAllowThreads(__tstate);
10200 if (PyErr_Occurred()) SWIG_fail;
10201 }
10202 {
10203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10204 }
10205 return resultobj;
10206 fail:
10207 return NULL;
10208 }
10209
10210
10211 static PyObject *_wrap_Font___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
10212 PyObject *resultobj;
10213 wxFont *arg1 = (wxFont *) 0 ;
10214 wxFont *arg2 = (wxFont *) 0 ;
10215 bool result;
10216 PyObject * obj0 = 0 ;
10217 PyObject * obj1 = 0 ;
10218 char *kwnames[] = {
10219 (char *) "self",(char *) "other", NULL
10220 };
10221
10222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___ne__",kwnames,&obj0,&obj1)) goto fail;
10223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10224 if (SWIG_arg_fail(1)) SWIG_fail;
10225 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10226 if (SWIG_arg_fail(2)) SWIG_fail;
10227 {
10228 PyThreadState* __tstate = wxPyBeginAllowThreads();
10229 result = (bool)wxFont___ne__(arg1,(wxFont const *)arg2);
10230
10231 wxPyEndAllowThreads(__tstate);
10232 if (PyErr_Occurred()) SWIG_fail;
10233 }
10234 {
10235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10236 }
10237 return resultobj;
10238 fail:
10239 return NULL;
10240 }
10241
10242
10243 static PyObject *_wrap_Font_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
10244 PyObject *resultobj;
10245 wxFont *arg1 = (wxFont *) 0 ;
10246 int result;
10247 PyObject * obj0 = 0 ;
10248 char *kwnames[] = {
10249 (char *) "self", NULL
10250 };
10251
10252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPointSize",kwnames,&obj0)) goto fail;
10253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10254 if (SWIG_arg_fail(1)) SWIG_fail;
10255 {
10256 PyThreadState* __tstate = wxPyBeginAllowThreads();
10257 result = (int)((wxFont const *)arg1)->GetPointSize();
10258
10259 wxPyEndAllowThreads(__tstate);
10260 if (PyErr_Occurred()) SWIG_fail;
10261 }
10262 {
10263 resultobj = SWIG_From_int((int)(result));
10264 }
10265 return resultobj;
10266 fail:
10267 return NULL;
10268 }
10269
10270
10271 static PyObject *_wrap_Font_GetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10272 PyObject *resultobj;
10273 wxFont *arg1 = (wxFont *) 0 ;
10274 wxSize result;
10275 PyObject * obj0 = 0 ;
10276 char *kwnames[] = {
10277 (char *) "self", NULL
10278 };
10279
10280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPixelSize",kwnames,&obj0)) goto fail;
10281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10282 if (SWIG_arg_fail(1)) SWIG_fail;
10283 {
10284 PyThreadState* __tstate = wxPyBeginAllowThreads();
10285 result = ((wxFont const *)arg1)->GetPixelSize();
10286
10287 wxPyEndAllowThreads(__tstate);
10288 if (PyErr_Occurred()) SWIG_fail;
10289 }
10290 {
10291 wxSize * resultptr;
10292 resultptr = new wxSize((wxSize &)(result));
10293 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
10294 }
10295 return resultobj;
10296 fail:
10297 return NULL;
10298 }
10299
10300
10301 static PyObject *_wrap_Font_IsUsingSizeInPixels(PyObject *, PyObject *args, PyObject *kwargs) {
10302 PyObject *resultobj;
10303 wxFont *arg1 = (wxFont *) 0 ;
10304 bool result;
10305 PyObject * obj0 = 0 ;
10306 char *kwnames[] = {
10307 (char *) "self", NULL
10308 };
10309
10310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsUsingSizeInPixels",kwnames,&obj0)) goto fail;
10311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10312 if (SWIG_arg_fail(1)) SWIG_fail;
10313 {
10314 PyThreadState* __tstate = wxPyBeginAllowThreads();
10315 result = (bool)((wxFont const *)arg1)->IsUsingSizeInPixels();
10316
10317 wxPyEndAllowThreads(__tstate);
10318 if (PyErr_Occurred()) SWIG_fail;
10319 }
10320 {
10321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10322 }
10323 return resultobj;
10324 fail:
10325 return NULL;
10326 }
10327
10328
10329 static PyObject *_wrap_Font_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
10330 PyObject *resultobj;
10331 wxFont *arg1 = (wxFont *) 0 ;
10332 int result;
10333 PyObject * obj0 = 0 ;
10334 char *kwnames[] = {
10335 (char *) "self", NULL
10336 };
10337
10338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamily",kwnames,&obj0)) goto fail;
10339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10340 if (SWIG_arg_fail(1)) SWIG_fail;
10341 {
10342 PyThreadState* __tstate = wxPyBeginAllowThreads();
10343 result = (int)((wxFont const *)arg1)->GetFamily();
10344
10345 wxPyEndAllowThreads(__tstate);
10346 if (PyErr_Occurred()) SWIG_fail;
10347 }
10348 {
10349 resultobj = SWIG_From_int((int)(result));
10350 }
10351 return resultobj;
10352 fail:
10353 return NULL;
10354 }
10355
10356
10357 static PyObject *_wrap_Font_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10358 PyObject *resultobj;
10359 wxFont *arg1 = (wxFont *) 0 ;
10360 int result;
10361 PyObject * obj0 = 0 ;
10362 char *kwnames[] = {
10363 (char *) "self", NULL
10364 };
10365
10366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyle",kwnames,&obj0)) goto fail;
10367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10368 if (SWIG_arg_fail(1)) SWIG_fail;
10369 {
10370 PyThreadState* __tstate = wxPyBeginAllowThreads();
10371 result = (int)((wxFont const *)arg1)->GetStyle();
10372
10373 wxPyEndAllowThreads(__tstate);
10374 if (PyErr_Occurred()) SWIG_fail;
10375 }
10376 {
10377 resultobj = SWIG_From_int((int)(result));
10378 }
10379 return resultobj;
10380 fail:
10381 return NULL;
10382 }
10383
10384
10385 static PyObject *_wrap_Font_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
10386 PyObject *resultobj;
10387 wxFont *arg1 = (wxFont *) 0 ;
10388 int result;
10389 PyObject * obj0 = 0 ;
10390 char *kwnames[] = {
10391 (char *) "self", NULL
10392 };
10393
10394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeight",kwnames,&obj0)) goto fail;
10395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10396 if (SWIG_arg_fail(1)) SWIG_fail;
10397 {
10398 PyThreadState* __tstate = wxPyBeginAllowThreads();
10399 result = (int)((wxFont const *)arg1)->GetWeight();
10400
10401 wxPyEndAllowThreads(__tstate);
10402 if (PyErr_Occurred()) SWIG_fail;
10403 }
10404 {
10405 resultobj = SWIG_From_int((int)(result));
10406 }
10407 return resultobj;
10408 fail:
10409 return NULL;
10410 }
10411
10412
10413 static PyObject *_wrap_Font_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
10414 PyObject *resultobj;
10415 wxFont *arg1 = (wxFont *) 0 ;
10416 bool result;
10417 PyObject * obj0 = 0 ;
10418 char *kwnames[] = {
10419 (char *) "self", NULL
10420 };
10421
10422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetUnderlined",kwnames,&obj0)) goto fail;
10423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10424 if (SWIG_arg_fail(1)) SWIG_fail;
10425 {
10426 PyThreadState* __tstate = wxPyBeginAllowThreads();
10427 result = (bool)((wxFont const *)arg1)->GetUnderlined();
10428
10429 wxPyEndAllowThreads(__tstate);
10430 if (PyErr_Occurred()) SWIG_fail;
10431 }
10432 {
10433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10434 }
10435 return resultobj;
10436 fail:
10437 return NULL;
10438 }
10439
10440
10441 static PyObject *_wrap_Font_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
10442 PyObject *resultobj;
10443 wxFont *arg1 = (wxFont *) 0 ;
10444 wxString result;
10445 PyObject * obj0 = 0 ;
10446 char *kwnames[] = {
10447 (char *) "self", NULL
10448 };
10449
10450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFaceName",kwnames,&obj0)) goto fail;
10451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10452 if (SWIG_arg_fail(1)) SWIG_fail;
10453 {
10454 PyThreadState* __tstate = wxPyBeginAllowThreads();
10455 result = ((wxFont const *)arg1)->GetFaceName();
10456
10457 wxPyEndAllowThreads(__tstate);
10458 if (PyErr_Occurred()) SWIG_fail;
10459 }
10460 {
10461 #if wxUSE_UNICODE
10462 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10463 #else
10464 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10465 #endif
10466 }
10467 return resultobj;
10468 fail:
10469 return NULL;
10470 }
10471
10472
10473 static PyObject *_wrap_Font_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10474 PyObject *resultobj;
10475 wxFont *arg1 = (wxFont *) 0 ;
10476 wxFontEncoding result;
10477 PyObject * obj0 = 0 ;
10478 char *kwnames[] = {
10479 (char *) "self", NULL
10480 };
10481
10482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetEncoding",kwnames,&obj0)) goto fail;
10483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10484 if (SWIG_arg_fail(1)) SWIG_fail;
10485 {
10486 PyThreadState* __tstate = wxPyBeginAllowThreads();
10487 result = (wxFontEncoding)((wxFont const *)arg1)->GetEncoding();
10488
10489 wxPyEndAllowThreads(__tstate);
10490 if (PyErr_Occurred()) SWIG_fail;
10491 }
10492 resultobj = SWIG_From_int((result));
10493 return resultobj;
10494 fail:
10495 return NULL;
10496 }
10497
10498
10499 static PyObject *_wrap_Font_GetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10500 PyObject *resultobj;
10501 wxFont *arg1 = (wxFont *) 0 ;
10502 wxNativeFontInfo *result;
10503 PyObject * obj0 = 0 ;
10504 char *kwnames[] = {
10505 (char *) "self", NULL
10506 };
10507
10508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfo",kwnames,&obj0)) goto fail;
10509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10510 if (SWIG_arg_fail(1)) SWIG_fail;
10511 {
10512 PyThreadState* __tstate = wxPyBeginAllowThreads();
10513 result = (wxNativeFontInfo *)((wxFont const *)arg1)->GetNativeFontInfo();
10514
10515 wxPyEndAllowThreads(__tstate);
10516 if (PyErr_Occurred()) SWIG_fail;
10517 }
10518 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 0);
10519 return resultobj;
10520 fail:
10521 return NULL;
10522 }
10523
10524
10525 static PyObject *_wrap_Font_IsFixedWidth(PyObject *, PyObject *args, PyObject *kwargs) {
10526 PyObject *resultobj;
10527 wxFont *arg1 = (wxFont *) 0 ;
10528 bool result;
10529 PyObject * obj0 = 0 ;
10530 char *kwnames[] = {
10531 (char *) "self", NULL
10532 };
10533
10534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsFixedWidth",kwnames,&obj0)) goto fail;
10535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10536 if (SWIG_arg_fail(1)) SWIG_fail;
10537 {
10538 PyThreadState* __tstate = wxPyBeginAllowThreads();
10539 result = (bool)((wxFont const *)arg1)->IsFixedWidth();
10540
10541 wxPyEndAllowThreads(__tstate);
10542 if (PyErr_Occurred()) SWIG_fail;
10543 }
10544 {
10545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10546 }
10547 return resultobj;
10548 fail:
10549 return NULL;
10550 }
10551
10552
10553 static PyObject *_wrap_Font_GetNativeFontInfoDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10554 PyObject *resultobj;
10555 wxFont *arg1 = (wxFont *) 0 ;
10556 wxString result;
10557 PyObject * obj0 = 0 ;
10558 char *kwnames[] = {
10559 (char *) "self", NULL
10560 };
10561
10562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoDesc",kwnames,&obj0)) goto fail;
10563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10564 if (SWIG_arg_fail(1)) SWIG_fail;
10565 {
10566 PyThreadState* __tstate = wxPyBeginAllowThreads();
10567 result = ((wxFont const *)arg1)->GetNativeFontInfoDesc();
10568
10569 wxPyEndAllowThreads(__tstate);
10570 if (PyErr_Occurred()) SWIG_fail;
10571 }
10572 {
10573 #if wxUSE_UNICODE
10574 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10575 #else
10576 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10577 #endif
10578 }
10579 return resultobj;
10580 fail:
10581 return NULL;
10582 }
10583
10584
10585 static PyObject *_wrap_Font_GetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10586 PyObject *resultobj;
10587 wxFont *arg1 = (wxFont *) 0 ;
10588 wxString result;
10589 PyObject * obj0 = 0 ;
10590 char *kwnames[] = {
10591 (char *) "self", NULL
10592 };
10593
10594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoUserDesc",kwnames,&obj0)) goto fail;
10595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10596 if (SWIG_arg_fail(1)) SWIG_fail;
10597 {
10598 PyThreadState* __tstate = wxPyBeginAllowThreads();
10599 result = ((wxFont const *)arg1)->GetNativeFontInfoUserDesc();
10600
10601 wxPyEndAllowThreads(__tstate);
10602 if (PyErr_Occurred()) SWIG_fail;
10603 }
10604 {
10605 #if wxUSE_UNICODE
10606 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10607 #else
10608 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10609 #endif
10610 }
10611 return resultobj;
10612 fail:
10613 return NULL;
10614 }
10615
10616
10617 static PyObject *_wrap_Font_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
10618 PyObject *resultobj;
10619 wxFont *arg1 = (wxFont *) 0 ;
10620 int arg2 ;
10621 PyObject * obj0 = 0 ;
10622 PyObject * obj1 = 0 ;
10623 char *kwnames[] = {
10624 (char *) "self",(char *) "pointSize", NULL
10625 };
10626
10627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
10628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10629 if (SWIG_arg_fail(1)) SWIG_fail;
10630 {
10631 arg2 = (int)(SWIG_As_int(obj1));
10632 if (SWIG_arg_fail(2)) SWIG_fail;
10633 }
10634 {
10635 PyThreadState* __tstate = wxPyBeginAllowThreads();
10636 (arg1)->SetPointSize(arg2);
10637
10638 wxPyEndAllowThreads(__tstate);
10639 if (PyErr_Occurred()) SWIG_fail;
10640 }
10641 Py_INCREF(Py_None); resultobj = Py_None;
10642 return resultobj;
10643 fail:
10644 return NULL;
10645 }
10646
10647
10648 static PyObject *_wrap_Font_SetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10649 PyObject *resultobj;
10650 wxFont *arg1 = (wxFont *) 0 ;
10651 wxSize *arg2 = 0 ;
10652 wxSize temp2 ;
10653 PyObject * obj0 = 0 ;
10654 PyObject * obj1 = 0 ;
10655 char *kwnames[] = {
10656 (char *) "self",(char *) "pixelSize", NULL
10657 };
10658
10659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPixelSize",kwnames,&obj0,&obj1)) goto fail;
10660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10661 if (SWIG_arg_fail(1)) SWIG_fail;
10662 {
10663 arg2 = &temp2;
10664 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
10665 }
10666 {
10667 PyThreadState* __tstate = wxPyBeginAllowThreads();
10668 (arg1)->SetPixelSize((wxSize const &)*arg2);
10669
10670 wxPyEndAllowThreads(__tstate);
10671 if (PyErr_Occurred()) SWIG_fail;
10672 }
10673 Py_INCREF(Py_None); resultobj = Py_None;
10674 return resultobj;
10675 fail:
10676 return NULL;
10677 }
10678
10679
10680 static PyObject *_wrap_Font_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
10681 PyObject *resultobj;
10682 wxFont *arg1 = (wxFont *) 0 ;
10683 int arg2 ;
10684 PyObject * obj0 = 0 ;
10685 PyObject * obj1 = 0 ;
10686 char *kwnames[] = {
10687 (char *) "self",(char *) "family", NULL
10688 };
10689
10690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFamily",kwnames,&obj0,&obj1)) goto fail;
10691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10692 if (SWIG_arg_fail(1)) SWIG_fail;
10693 {
10694 arg2 = (int)(SWIG_As_int(obj1));
10695 if (SWIG_arg_fail(2)) SWIG_fail;
10696 }
10697 {
10698 PyThreadState* __tstate = wxPyBeginAllowThreads();
10699 (arg1)->SetFamily(arg2);
10700
10701 wxPyEndAllowThreads(__tstate);
10702 if (PyErr_Occurred()) SWIG_fail;
10703 }
10704 Py_INCREF(Py_None); resultobj = Py_None;
10705 return resultobj;
10706 fail:
10707 return NULL;
10708 }
10709
10710
10711 static PyObject *_wrap_Font_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10712 PyObject *resultobj;
10713 wxFont *arg1 = (wxFont *) 0 ;
10714 int arg2 ;
10715 PyObject * obj0 = 0 ;
10716 PyObject * obj1 = 0 ;
10717 char *kwnames[] = {
10718 (char *) "self",(char *) "style", NULL
10719 };
10720
10721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetStyle",kwnames,&obj0,&obj1)) goto fail;
10722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10723 if (SWIG_arg_fail(1)) SWIG_fail;
10724 {
10725 arg2 = (int)(SWIG_As_int(obj1));
10726 if (SWIG_arg_fail(2)) SWIG_fail;
10727 }
10728 {
10729 PyThreadState* __tstate = wxPyBeginAllowThreads();
10730 (arg1)->SetStyle(arg2);
10731
10732 wxPyEndAllowThreads(__tstate);
10733 if (PyErr_Occurred()) SWIG_fail;
10734 }
10735 Py_INCREF(Py_None); resultobj = Py_None;
10736 return resultobj;
10737 fail:
10738 return NULL;
10739 }
10740
10741
10742 static PyObject *_wrap_Font_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
10743 PyObject *resultobj;
10744 wxFont *arg1 = (wxFont *) 0 ;
10745 int arg2 ;
10746 PyObject * obj0 = 0 ;
10747 PyObject * obj1 = 0 ;
10748 char *kwnames[] = {
10749 (char *) "self",(char *) "weight", NULL
10750 };
10751
10752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetWeight",kwnames,&obj0,&obj1)) goto fail;
10753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10754 if (SWIG_arg_fail(1)) SWIG_fail;
10755 {
10756 arg2 = (int)(SWIG_As_int(obj1));
10757 if (SWIG_arg_fail(2)) SWIG_fail;
10758 }
10759 {
10760 PyThreadState* __tstate = wxPyBeginAllowThreads();
10761 (arg1)->SetWeight(arg2);
10762
10763 wxPyEndAllowThreads(__tstate);
10764 if (PyErr_Occurred()) SWIG_fail;
10765 }
10766 Py_INCREF(Py_None); resultobj = Py_None;
10767 return resultobj;
10768 fail:
10769 return NULL;
10770 }
10771
10772
10773 static PyObject *_wrap_Font_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
10774 PyObject *resultobj;
10775 wxFont *arg1 = (wxFont *) 0 ;
10776 wxString *arg2 = 0 ;
10777 bool temp2 = false ;
10778 PyObject * obj0 = 0 ;
10779 PyObject * obj1 = 0 ;
10780 char *kwnames[] = {
10781 (char *) "self",(char *) "faceName", NULL
10782 };
10783
10784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
10785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10786 if (SWIG_arg_fail(1)) SWIG_fail;
10787 {
10788 arg2 = wxString_in_helper(obj1);
10789 if (arg2 == NULL) SWIG_fail;
10790 temp2 = true;
10791 }
10792 {
10793 PyThreadState* __tstate = wxPyBeginAllowThreads();
10794 (arg1)->SetFaceName((wxString const &)*arg2);
10795
10796 wxPyEndAllowThreads(__tstate);
10797 if (PyErr_Occurred()) SWIG_fail;
10798 }
10799 Py_INCREF(Py_None); resultobj = Py_None;
10800 {
10801 if (temp2)
10802 delete arg2;
10803 }
10804 return resultobj;
10805 fail:
10806 {
10807 if (temp2)
10808 delete arg2;
10809 }
10810 return NULL;
10811 }
10812
10813
10814 static PyObject *_wrap_Font_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
10815 PyObject *resultobj;
10816 wxFont *arg1 = (wxFont *) 0 ;
10817 bool arg2 ;
10818 PyObject * obj0 = 0 ;
10819 PyObject * obj1 = 0 ;
10820 char *kwnames[] = {
10821 (char *) "self",(char *) "underlined", NULL
10822 };
10823
10824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
10825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10826 if (SWIG_arg_fail(1)) SWIG_fail;
10827 {
10828 arg2 = (bool)(SWIG_As_bool(obj1));
10829 if (SWIG_arg_fail(2)) SWIG_fail;
10830 }
10831 {
10832 PyThreadState* __tstate = wxPyBeginAllowThreads();
10833 (arg1)->SetUnderlined(arg2);
10834
10835 wxPyEndAllowThreads(__tstate);
10836 if (PyErr_Occurred()) SWIG_fail;
10837 }
10838 Py_INCREF(Py_None); resultobj = Py_None;
10839 return resultobj;
10840 fail:
10841 return NULL;
10842 }
10843
10844
10845 static PyObject *_wrap_Font_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10846 PyObject *resultobj;
10847 wxFont *arg1 = (wxFont *) 0 ;
10848 wxFontEncoding arg2 ;
10849 PyObject * obj0 = 0 ;
10850 PyObject * obj1 = 0 ;
10851 char *kwnames[] = {
10852 (char *) "self",(char *) "encoding", NULL
10853 };
10854
10855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
10856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10857 if (SWIG_arg_fail(1)) SWIG_fail;
10858 {
10859 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10860 if (SWIG_arg_fail(2)) SWIG_fail;
10861 }
10862 {
10863 PyThreadState* __tstate = wxPyBeginAllowThreads();
10864 (arg1)->SetEncoding((wxFontEncoding )arg2);
10865
10866 wxPyEndAllowThreads(__tstate);
10867 if (PyErr_Occurred()) SWIG_fail;
10868 }
10869 Py_INCREF(Py_None); resultobj = Py_None;
10870 return resultobj;
10871 fail:
10872 return NULL;
10873 }
10874
10875
10876 static PyObject *_wrap_Font_SetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10877 PyObject *resultobj;
10878 wxFont *arg1 = (wxFont *) 0 ;
10879 wxNativeFontInfo *arg2 = 0 ;
10880 PyObject * obj0 = 0 ;
10881 PyObject * obj1 = 0 ;
10882 char *kwnames[] = {
10883 (char *) "self",(char *) "info", NULL
10884 };
10885
10886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfo",kwnames,&obj0,&obj1)) goto fail;
10887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10888 if (SWIG_arg_fail(1)) SWIG_fail;
10889 {
10890 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
10891 if (SWIG_arg_fail(2)) SWIG_fail;
10892 if (arg2 == NULL) {
10893 SWIG_null_ref("wxNativeFontInfo");
10894 }
10895 if (SWIG_arg_fail(2)) SWIG_fail;
10896 }
10897 {
10898 PyThreadState* __tstate = wxPyBeginAllowThreads();
10899 (arg1)->SetNativeFontInfo((wxNativeFontInfo const &)*arg2);
10900
10901 wxPyEndAllowThreads(__tstate);
10902 if (PyErr_Occurred()) SWIG_fail;
10903 }
10904 Py_INCREF(Py_None); resultobj = Py_None;
10905 return resultobj;
10906 fail:
10907 return NULL;
10908 }
10909
10910
10911 static PyObject *_wrap_Font_SetNativeFontInfoFromString(PyObject *, PyObject *args, PyObject *kwargs) {
10912 PyObject *resultobj;
10913 wxFont *arg1 = (wxFont *) 0 ;
10914 wxString *arg2 = 0 ;
10915 bool temp2 = false ;
10916 PyObject * obj0 = 0 ;
10917 PyObject * obj1 = 0 ;
10918 char *kwnames[] = {
10919 (char *) "self",(char *) "info", NULL
10920 };
10921
10922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoFromString",kwnames,&obj0,&obj1)) goto fail;
10923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10924 if (SWIG_arg_fail(1)) SWIG_fail;
10925 {
10926 arg2 = wxString_in_helper(obj1);
10927 if (arg2 == NULL) SWIG_fail;
10928 temp2 = true;
10929 }
10930 {
10931 PyThreadState* __tstate = wxPyBeginAllowThreads();
10932 (arg1)->SetNativeFontInfo((wxString const &)*arg2);
10933
10934 wxPyEndAllowThreads(__tstate);
10935 if (PyErr_Occurred()) SWIG_fail;
10936 }
10937 Py_INCREF(Py_None); resultobj = Py_None;
10938 {
10939 if (temp2)
10940 delete arg2;
10941 }
10942 return resultobj;
10943 fail:
10944 {
10945 if (temp2)
10946 delete arg2;
10947 }
10948 return NULL;
10949 }
10950
10951
10952 static PyObject *_wrap_Font_SetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10953 PyObject *resultobj;
10954 wxFont *arg1 = (wxFont *) 0 ;
10955 wxString *arg2 = 0 ;
10956 bool temp2 = false ;
10957 PyObject * obj0 = 0 ;
10958 PyObject * obj1 = 0 ;
10959 char *kwnames[] = {
10960 (char *) "self",(char *) "info", NULL
10961 };
10962
10963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoUserDesc",kwnames,&obj0,&obj1)) goto fail;
10964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10965 if (SWIG_arg_fail(1)) SWIG_fail;
10966 {
10967 arg2 = wxString_in_helper(obj1);
10968 if (arg2 == NULL) SWIG_fail;
10969 temp2 = true;
10970 }
10971 {
10972 PyThreadState* __tstate = wxPyBeginAllowThreads();
10973 (arg1)->SetNativeFontInfoUserDesc((wxString const &)*arg2);
10974
10975 wxPyEndAllowThreads(__tstate);
10976 if (PyErr_Occurred()) SWIG_fail;
10977 }
10978 Py_INCREF(Py_None); resultobj = Py_None;
10979 {
10980 if (temp2)
10981 delete arg2;
10982 }
10983 return resultobj;
10984 fail:
10985 {
10986 if (temp2)
10987 delete arg2;
10988 }
10989 return NULL;
10990 }
10991
10992
10993 static PyObject *_wrap_Font_GetFamilyString(PyObject *, PyObject *args, PyObject *kwargs) {
10994 PyObject *resultobj;
10995 wxFont *arg1 = (wxFont *) 0 ;
10996 wxString result;
10997 PyObject * obj0 = 0 ;
10998 char *kwnames[] = {
10999 (char *) "self", NULL
11000 };
11001
11002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamilyString",kwnames,&obj0)) goto fail;
11003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11004 if (SWIG_arg_fail(1)) SWIG_fail;
11005 {
11006 PyThreadState* __tstate = wxPyBeginAllowThreads();
11007 result = ((wxFont const *)arg1)->GetFamilyString();
11008
11009 wxPyEndAllowThreads(__tstate);
11010 if (PyErr_Occurred()) SWIG_fail;
11011 }
11012 {
11013 #if wxUSE_UNICODE
11014 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11015 #else
11016 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11017 #endif
11018 }
11019 return resultobj;
11020 fail:
11021 return NULL;
11022 }
11023
11024
11025 static PyObject *_wrap_Font_GetStyleString(PyObject *, PyObject *args, PyObject *kwargs) {
11026 PyObject *resultobj;
11027 wxFont *arg1 = (wxFont *) 0 ;
11028 wxString result;
11029 PyObject * obj0 = 0 ;
11030 char *kwnames[] = {
11031 (char *) "self", NULL
11032 };
11033
11034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyleString",kwnames,&obj0)) goto fail;
11035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11036 if (SWIG_arg_fail(1)) SWIG_fail;
11037 {
11038 PyThreadState* __tstate = wxPyBeginAllowThreads();
11039 result = ((wxFont const *)arg1)->GetStyleString();
11040
11041 wxPyEndAllowThreads(__tstate);
11042 if (PyErr_Occurred()) SWIG_fail;
11043 }
11044 {
11045 #if wxUSE_UNICODE
11046 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11047 #else
11048 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11049 #endif
11050 }
11051 return resultobj;
11052 fail:
11053 return NULL;
11054 }
11055
11056
11057 static PyObject *_wrap_Font_GetWeightString(PyObject *, PyObject *args, PyObject *kwargs) {
11058 PyObject *resultobj;
11059 wxFont *arg1 = (wxFont *) 0 ;
11060 wxString result;
11061 PyObject * obj0 = 0 ;
11062 char *kwnames[] = {
11063 (char *) "self", NULL
11064 };
11065
11066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeightString",kwnames,&obj0)) goto fail;
11067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11068 if (SWIG_arg_fail(1)) SWIG_fail;
11069 {
11070 PyThreadState* __tstate = wxPyBeginAllowThreads();
11071 result = ((wxFont const *)arg1)->GetWeightString();
11072
11073 wxPyEndAllowThreads(__tstate);
11074 if (PyErr_Occurred()) SWIG_fail;
11075 }
11076 {
11077 #if wxUSE_UNICODE
11078 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11079 #else
11080 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11081 #endif
11082 }
11083 return resultobj;
11084 fail:
11085 return NULL;
11086 }
11087
11088
11089 static PyObject *_wrap_Font_SetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
11090 PyObject *resultobj;
11091 wxFont *arg1 = (wxFont *) 0 ;
11092 bool arg2 = (bool) true ;
11093 PyObject * obj0 = 0 ;
11094 PyObject * obj1 = 0 ;
11095 char *kwnames[] = {
11096 (char *) "self",(char *) "no", NULL
11097 };
11098
11099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Font_SetNoAntiAliasing",kwnames,&obj0,&obj1)) goto fail;
11100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11101 if (SWIG_arg_fail(1)) SWIG_fail;
11102 if (obj1) {
11103 {
11104 arg2 = (bool)(SWIG_As_bool(obj1));
11105 if (SWIG_arg_fail(2)) SWIG_fail;
11106 }
11107 }
11108 {
11109 PyThreadState* __tstate = wxPyBeginAllowThreads();
11110 (arg1)->SetNoAntiAliasing(arg2);
11111
11112 wxPyEndAllowThreads(__tstate);
11113 if (PyErr_Occurred()) SWIG_fail;
11114 }
11115 Py_INCREF(Py_None); resultobj = Py_None;
11116 return resultobj;
11117 fail:
11118 return NULL;
11119 }
11120
11121
11122 static PyObject *_wrap_Font_GetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
11123 PyObject *resultobj;
11124 wxFont *arg1 = (wxFont *) 0 ;
11125 bool result;
11126 PyObject * obj0 = 0 ;
11127 char *kwnames[] = {
11128 (char *) "self", NULL
11129 };
11130
11131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNoAntiAliasing",kwnames,&obj0)) goto fail;
11132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11133 if (SWIG_arg_fail(1)) SWIG_fail;
11134 {
11135 PyThreadState* __tstate = wxPyBeginAllowThreads();
11136 result = (bool)((wxFont const *)arg1)->GetNoAntiAliasing();
11137
11138 wxPyEndAllowThreads(__tstate);
11139 if (PyErr_Occurred()) SWIG_fail;
11140 }
11141 {
11142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11143 }
11144 return resultobj;
11145 fail:
11146 return NULL;
11147 }
11148
11149
11150 static PyObject *_wrap_Font_GetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11151 PyObject *resultobj;
11152 wxFontEncoding result;
11153 char *kwnames[] = {
11154 NULL
11155 };
11156
11157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Font_GetDefaultEncoding",kwnames)) goto fail;
11158 {
11159 if (!wxPyCheckForApp()) SWIG_fail;
11160 PyThreadState* __tstate = wxPyBeginAllowThreads();
11161 result = (wxFontEncoding)wxFont::GetDefaultEncoding();
11162
11163 wxPyEndAllowThreads(__tstate);
11164 if (PyErr_Occurred()) SWIG_fail;
11165 }
11166 resultobj = SWIG_From_int((result));
11167 return resultobj;
11168 fail:
11169 return NULL;
11170 }
11171
11172
11173 static PyObject *_wrap_Font_SetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11174 PyObject *resultobj;
11175 wxFontEncoding arg1 ;
11176 PyObject * obj0 = 0 ;
11177 char *kwnames[] = {
11178 (char *) "encoding", NULL
11179 };
11180
11181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_SetDefaultEncoding",kwnames,&obj0)) goto fail;
11182 {
11183 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
11184 if (SWIG_arg_fail(1)) SWIG_fail;
11185 }
11186 {
11187 if (!wxPyCheckForApp()) SWIG_fail;
11188 PyThreadState* __tstate = wxPyBeginAllowThreads();
11189 wxFont::SetDefaultEncoding((wxFontEncoding )arg1);
11190
11191 wxPyEndAllowThreads(__tstate);
11192 if (PyErr_Occurred()) SWIG_fail;
11193 }
11194 Py_INCREF(Py_None); resultobj = Py_None;
11195 return resultobj;
11196 fail:
11197 return NULL;
11198 }
11199
11200
11201 static PyObject * Font_swigregister(PyObject *, PyObject *args) {
11202 PyObject *obj;
11203 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11204 SWIG_TypeClientData(SWIGTYPE_p_wxFont, obj);
11205 Py_INCREF(obj);
11206 return Py_BuildValue((char *)"");
11207 }
11208 static PyObject *_wrap_new_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
11209 PyObject *resultobj;
11210 wxPyFontEnumerator *result;
11211 char *kwnames[] = {
11212 NULL
11213 };
11214
11215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontEnumerator",kwnames)) goto fail;
11216 {
11217 if (!wxPyCheckForApp()) SWIG_fail;
11218 PyThreadState* __tstate = wxPyBeginAllowThreads();
11219 result = (wxPyFontEnumerator *)new wxPyFontEnumerator();
11220
11221 wxPyEndAllowThreads(__tstate);
11222 if (PyErr_Occurred()) SWIG_fail;
11223 }
11224 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFontEnumerator, 1);
11225 return resultobj;
11226 fail:
11227 return NULL;
11228 }
11229
11230
11231 static PyObject *_wrap_delete_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
11232 PyObject *resultobj;
11233 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11234 PyObject * obj0 = 0 ;
11235 char *kwnames[] = {
11236 (char *) "self", NULL
11237 };
11238
11239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontEnumerator",kwnames,&obj0)) goto fail;
11240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11241 if (SWIG_arg_fail(1)) SWIG_fail;
11242 {
11243 PyThreadState* __tstate = wxPyBeginAllowThreads();
11244 delete arg1;
11245
11246 wxPyEndAllowThreads(__tstate);
11247 if (PyErr_Occurred()) SWIG_fail;
11248 }
11249 Py_INCREF(Py_None); resultobj = Py_None;
11250 return resultobj;
11251 fail:
11252 return NULL;
11253 }
11254
11255
11256 static PyObject *_wrap_FontEnumerator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11257 PyObject *resultobj;
11258 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11259 PyObject *arg2 = (PyObject *) 0 ;
11260 PyObject *arg3 = (PyObject *) 0 ;
11261 bool arg4 ;
11262 PyObject * obj0 = 0 ;
11263 PyObject * obj1 = 0 ;
11264 PyObject * obj2 = 0 ;
11265 PyObject * obj3 = 0 ;
11266 char *kwnames[] = {
11267 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11268 };
11269
11270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FontEnumerator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11272 if (SWIG_arg_fail(1)) SWIG_fail;
11273 arg2 = obj1;
11274 arg3 = obj2;
11275 {
11276 arg4 = (bool)(SWIG_As_bool(obj3));
11277 if (SWIG_arg_fail(4)) SWIG_fail;
11278 }
11279 {
11280 PyThreadState* __tstate = wxPyBeginAllowThreads();
11281 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11282
11283 wxPyEndAllowThreads(__tstate);
11284 if (PyErr_Occurred()) SWIG_fail;
11285 }
11286 Py_INCREF(Py_None); resultobj = Py_None;
11287 return resultobj;
11288 fail:
11289 return NULL;
11290 }
11291
11292
11293 static PyObject *_wrap_FontEnumerator_EnumerateFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
11294 PyObject *resultobj;
11295 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11296 wxFontEncoding arg2 = (wxFontEncoding) wxFONTENCODING_SYSTEM ;
11297 bool arg3 = (bool) false ;
11298 bool result;
11299 PyObject * obj0 = 0 ;
11300 PyObject * obj1 = 0 ;
11301 PyObject * obj2 = 0 ;
11302 char *kwnames[] = {
11303 (char *) "self",(char *) "encoding",(char *) "fixedWidthOnly", NULL
11304 };
11305
11306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FontEnumerator_EnumerateFacenames",kwnames,&obj0,&obj1,&obj2)) goto fail;
11307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11308 if (SWIG_arg_fail(1)) SWIG_fail;
11309 if (obj1) {
11310 {
11311 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
11312 if (SWIG_arg_fail(2)) SWIG_fail;
11313 }
11314 }
11315 if (obj2) {
11316 {
11317 arg3 = (bool)(SWIG_As_bool(obj2));
11318 if (SWIG_arg_fail(3)) SWIG_fail;
11319 }
11320 }
11321 {
11322 PyThreadState* __tstate = wxPyBeginAllowThreads();
11323 result = (bool)(arg1)->EnumerateFacenames((wxFontEncoding )arg2,arg3);
11324
11325 wxPyEndAllowThreads(__tstate);
11326 if (PyErr_Occurred()) SWIG_fail;
11327 }
11328 {
11329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11330 }
11331 return resultobj;
11332 fail:
11333 return NULL;
11334 }
11335
11336
11337 static PyObject *_wrap_FontEnumerator_EnumerateEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
11338 PyObject *resultobj;
11339 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11340 wxString const &arg2_defvalue = wxPyEmptyString ;
11341 wxString *arg2 = (wxString *) &arg2_defvalue ;
11342 bool result;
11343 bool temp2 = false ;
11344 PyObject * obj0 = 0 ;
11345 PyObject * obj1 = 0 ;
11346 char *kwnames[] = {
11347 (char *) "self",(char *) "facename", NULL
11348 };
11349
11350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FontEnumerator_EnumerateEncodings",kwnames,&obj0,&obj1)) goto fail;
11351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11352 if (SWIG_arg_fail(1)) SWIG_fail;
11353 if (obj1) {
11354 {
11355 arg2 = wxString_in_helper(obj1);
11356 if (arg2 == NULL) SWIG_fail;
11357 temp2 = true;
11358 }
11359 }
11360 {
11361 PyThreadState* __tstate = wxPyBeginAllowThreads();
11362 result = (bool)(arg1)->EnumerateEncodings((wxString const &)*arg2);
11363
11364 wxPyEndAllowThreads(__tstate);
11365 if (PyErr_Occurred()) SWIG_fail;
11366 }
11367 {
11368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11369 }
11370 {
11371 if (temp2)
11372 delete arg2;
11373 }
11374 return resultobj;
11375 fail:
11376 {
11377 if (temp2)
11378 delete arg2;
11379 }
11380 return NULL;
11381 }
11382
11383
11384 static PyObject *_wrap_FontEnumerator_GetEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
11385 PyObject *resultobj;
11386 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11387 PyObject *result;
11388 PyObject * obj0 = 0 ;
11389 char *kwnames[] = {
11390 (char *) "self", NULL
11391 };
11392
11393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetEncodings",kwnames,&obj0)) goto fail;
11394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11395 if (SWIG_arg_fail(1)) SWIG_fail;
11396 {
11397 PyThreadState* __tstate = wxPyBeginAllowThreads();
11398 result = (PyObject *)wxPyFontEnumerator_GetEncodings(arg1);
11399
11400 wxPyEndAllowThreads(__tstate);
11401 if (PyErr_Occurred()) SWIG_fail;
11402 }
11403 resultobj = result;
11404 return resultobj;
11405 fail:
11406 return NULL;
11407 }
11408
11409
11410 static PyObject *_wrap_FontEnumerator_GetFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
11411 PyObject *resultobj;
11412 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11413 PyObject *result;
11414 PyObject * obj0 = 0 ;
11415 char *kwnames[] = {
11416 (char *) "self", NULL
11417 };
11418
11419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetFacenames",kwnames,&obj0)) goto fail;
11420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11421 if (SWIG_arg_fail(1)) SWIG_fail;
11422 {
11423 PyThreadState* __tstate = wxPyBeginAllowThreads();
11424 result = (PyObject *)wxPyFontEnumerator_GetFacenames(arg1);
11425
11426 wxPyEndAllowThreads(__tstate);
11427 if (PyErr_Occurred()) SWIG_fail;
11428 }
11429 resultobj = result;
11430 return resultobj;
11431 fail:
11432 return NULL;
11433 }
11434
11435
11436 static PyObject * FontEnumerator_swigregister(PyObject *, PyObject *args) {
11437 PyObject *obj;
11438 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11439 SWIG_TypeClientData(SWIGTYPE_p_wxPyFontEnumerator, obj);
11440 Py_INCREF(obj);
11441 return Py_BuildValue((char *)"");
11442 }
11443 static PyObject *_wrap_LanguageInfo_Language_set(PyObject *, PyObject *args, PyObject *kwargs) {
11444 PyObject *resultobj;
11445 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11446 int arg2 ;
11447 PyObject * obj0 = 0 ;
11448 PyObject * obj1 = 0 ;
11449 char *kwnames[] = {
11450 (char *) "self",(char *) "Language", NULL
11451 };
11452
11453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Language_set",kwnames,&obj0,&obj1)) goto fail;
11454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11455 if (SWIG_arg_fail(1)) SWIG_fail;
11456 {
11457 arg2 = (int)(SWIG_As_int(obj1));
11458 if (SWIG_arg_fail(2)) SWIG_fail;
11459 }
11460 if (arg1) (arg1)->Language = arg2;
11461
11462 Py_INCREF(Py_None); resultobj = Py_None;
11463 return resultobj;
11464 fail:
11465 return NULL;
11466 }
11467
11468
11469 static PyObject *_wrap_LanguageInfo_Language_get(PyObject *, PyObject *args, PyObject *kwargs) {
11470 PyObject *resultobj;
11471 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11472 int result;
11473 PyObject * obj0 = 0 ;
11474 char *kwnames[] = {
11475 (char *) "self", NULL
11476 };
11477
11478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Language_get",kwnames,&obj0)) goto fail;
11479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11480 if (SWIG_arg_fail(1)) SWIG_fail;
11481 result = (int) ((arg1)->Language);
11482
11483 {
11484 resultobj = SWIG_From_int((int)(result));
11485 }
11486 return resultobj;
11487 fail:
11488 return NULL;
11489 }
11490
11491
11492 static PyObject *_wrap_LanguageInfo_CanonicalName_set(PyObject *, PyObject *args, PyObject *kwargs) {
11493 PyObject *resultobj;
11494 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11495 wxString *arg2 = (wxString *) 0 ;
11496 bool temp2 = false ;
11497 PyObject * obj0 = 0 ;
11498 PyObject * obj1 = 0 ;
11499 char *kwnames[] = {
11500 (char *) "self",(char *) "CanonicalName", NULL
11501 };
11502
11503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_CanonicalName_set",kwnames,&obj0,&obj1)) goto fail;
11504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11505 if (SWIG_arg_fail(1)) SWIG_fail;
11506 {
11507 arg2 = wxString_in_helper(obj1);
11508 if (arg2 == NULL) SWIG_fail;
11509 temp2 = true;
11510 }
11511 if (arg1) (arg1)->CanonicalName = *arg2;
11512
11513 Py_INCREF(Py_None); resultobj = Py_None;
11514 {
11515 if (temp2)
11516 delete arg2;
11517 }
11518 return resultobj;
11519 fail:
11520 {
11521 if (temp2)
11522 delete arg2;
11523 }
11524 return NULL;
11525 }
11526
11527
11528 static PyObject *_wrap_LanguageInfo_CanonicalName_get(PyObject *, PyObject *args, PyObject *kwargs) {
11529 PyObject *resultobj;
11530 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11531 wxString *result;
11532 PyObject * obj0 = 0 ;
11533 char *kwnames[] = {
11534 (char *) "self", NULL
11535 };
11536
11537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_CanonicalName_get",kwnames,&obj0)) goto fail;
11538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11539 if (SWIG_arg_fail(1)) SWIG_fail;
11540 result = (wxString *)& ((arg1)->CanonicalName);
11541
11542 {
11543 #if wxUSE_UNICODE
11544 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11545 #else
11546 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11547 #endif
11548 }
11549 return resultobj;
11550 fail:
11551 return NULL;
11552 }
11553
11554
11555 static PyObject *_wrap_LanguageInfo_Description_set(PyObject *, PyObject *args, PyObject *kwargs) {
11556 PyObject *resultobj;
11557 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11558 wxString *arg2 = (wxString *) 0 ;
11559 bool temp2 = false ;
11560 PyObject * obj0 = 0 ;
11561 PyObject * obj1 = 0 ;
11562 char *kwnames[] = {
11563 (char *) "self",(char *) "Description", NULL
11564 };
11565
11566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Description_set",kwnames,&obj0,&obj1)) goto fail;
11567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11568 if (SWIG_arg_fail(1)) SWIG_fail;
11569 {
11570 arg2 = wxString_in_helper(obj1);
11571 if (arg2 == NULL) SWIG_fail;
11572 temp2 = true;
11573 }
11574 if (arg1) (arg1)->Description = *arg2;
11575
11576 Py_INCREF(Py_None); resultobj = Py_None;
11577 {
11578 if (temp2)
11579 delete arg2;
11580 }
11581 return resultobj;
11582 fail:
11583 {
11584 if (temp2)
11585 delete arg2;
11586 }
11587 return NULL;
11588 }
11589
11590
11591 static PyObject *_wrap_LanguageInfo_Description_get(PyObject *, PyObject *args, PyObject *kwargs) {
11592 PyObject *resultobj;
11593 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11594 wxString *result;
11595 PyObject * obj0 = 0 ;
11596 char *kwnames[] = {
11597 (char *) "self", NULL
11598 };
11599
11600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Description_get",kwnames,&obj0)) goto fail;
11601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11602 if (SWIG_arg_fail(1)) SWIG_fail;
11603 result = (wxString *)& ((arg1)->Description);
11604
11605 {
11606 #if wxUSE_UNICODE
11607 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11608 #else
11609 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11610 #endif
11611 }
11612 return resultobj;
11613 fail:
11614 return NULL;
11615 }
11616
11617
11618 static PyObject * LanguageInfo_swigregister(PyObject *, PyObject *args) {
11619 PyObject *obj;
11620 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11621 SWIG_TypeClientData(SWIGTYPE_p_wxLanguageInfo, obj);
11622 Py_INCREF(obj);
11623 return Py_BuildValue((char *)"");
11624 }
11625 static PyObject *_wrap_new_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11626 PyObject *resultobj;
11627 int arg1 = (int) -1 ;
11628 int arg2 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11629 wxLocale *result;
11630 PyObject * obj0 = 0 ;
11631 PyObject * obj1 = 0 ;
11632 char *kwnames[] = {
11633 (char *) "language",(char *) "flags", NULL
11634 };
11635
11636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Locale",kwnames,&obj0,&obj1)) goto fail;
11637 if (obj0) {
11638 {
11639 arg1 = (int)(SWIG_As_int(obj0));
11640 if (SWIG_arg_fail(1)) SWIG_fail;
11641 }
11642 }
11643 if (obj1) {
11644 {
11645 arg2 = (int)(SWIG_As_int(obj1));
11646 if (SWIG_arg_fail(2)) SWIG_fail;
11647 }
11648 }
11649 {
11650 PyThreadState* __tstate = wxPyBeginAllowThreads();
11651 result = (wxLocale *)new_wxLocale(arg1,arg2);
11652
11653 wxPyEndAllowThreads(__tstate);
11654 if (PyErr_Occurred()) SWIG_fail;
11655 }
11656 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 1);
11657 return resultobj;
11658 fail:
11659 return NULL;
11660 }
11661
11662
11663 static PyObject *_wrap_delete_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11664 PyObject *resultobj;
11665 wxLocale *arg1 = (wxLocale *) 0 ;
11666 PyObject * obj0 = 0 ;
11667 char *kwnames[] = {
11668 (char *) "self", NULL
11669 };
11670
11671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Locale",kwnames,&obj0)) goto fail;
11672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11673 if (SWIG_arg_fail(1)) SWIG_fail;
11674 {
11675 PyThreadState* __tstate = wxPyBeginAllowThreads();
11676 delete arg1;
11677
11678 wxPyEndAllowThreads(__tstate);
11679 if (PyErr_Occurred()) SWIG_fail;
11680 }
11681 Py_INCREF(Py_None); resultobj = Py_None;
11682 return resultobj;
11683 fail:
11684 return NULL;
11685 }
11686
11687
11688 static PyObject *_wrap_Locale_Init1(PyObject *, PyObject *args, PyObject *kwargs) {
11689 PyObject *resultobj;
11690 wxLocale *arg1 = (wxLocale *) 0 ;
11691 wxString *arg2 = 0 ;
11692 wxString const &arg3_defvalue = wxPyEmptyString ;
11693 wxString *arg3 = (wxString *) &arg3_defvalue ;
11694 wxString const &arg4_defvalue = wxPyEmptyString ;
11695 wxString *arg4 = (wxString *) &arg4_defvalue ;
11696 bool arg5 = (bool) true ;
11697 bool arg6 = (bool) false ;
11698 bool result;
11699 bool temp2 = false ;
11700 bool temp3 = false ;
11701 bool temp4 = false ;
11702 PyObject * obj0 = 0 ;
11703 PyObject * obj1 = 0 ;
11704 PyObject * obj2 = 0 ;
11705 PyObject * obj3 = 0 ;
11706 PyObject * obj4 = 0 ;
11707 PyObject * obj5 = 0 ;
11708 char *kwnames[] = {
11709 (char *) "self",(char *) "szName",(char *) "szShort",(char *) "szLocale",(char *) "bLoadDefault",(char *) "bConvertEncoding", NULL
11710 };
11711
11712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Locale_Init1",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11714 if (SWIG_arg_fail(1)) SWIG_fail;
11715 {
11716 arg2 = wxString_in_helper(obj1);
11717 if (arg2 == NULL) SWIG_fail;
11718 temp2 = true;
11719 }
11720 if (obj2) {
11721 {
11722 arg3 = wxString_in_helper(obj2);
11723 if (arg3 == NULL) SWIG_fail;
11724 temp3 = true;
11725 }
11726 }
11727 if (obj3) {
11728 {
11729 arg4 = wxString_in_helper(obj3);
11730 if (arg4 == NULL) SWIG_fail;
11731 temp4 = true;
11732 }
11733 }
11734 if (obj4) {
11735 {
11736 arg5 = (bool)(SWIG_As_bool(obj4));
11737 if (SWIG_arg_fail(5)) SWIG_fail;
11738 }
11739 }
11740 if (obj5) {
11741 {
11742 arg6 = (bool)(SWIG_As_bool(obj5));
11743 if (SWIG_arg_fail(6)) SWIG_fail;
11744 }
11745 }
11746 {
11747 PyThreadState* __tstate = wxPyBeginAllowThreads();
11748 result = (bool)wxLocale_Init1(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
11749
11750 wxPyEndAllowThreads(__tstate);
11751 if (PyErr_Occurred()) SWIG_fail;
11752 }
11753 {
11754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11755 }
11756 {
11757 if (temp2)
11758 delete arg2;
11759 }
11760 {
11761 if (temp3)
11762 delete arg3;
11763 }
11764 {
11765 if (temp4)
11766 delete arg4;
11767 }
11768 return resultobj;
11769 fail:
11770 {
11771 if (temp2)
11772 delete arg2;
11773 }
11774 {
11775 if (temp3)
11776 delete arg3;
11777 }
11778 {
11779 if (temp4)
11780 delete arg4;
11781 }
11782 return NULL;
11783 }
11784
11785
11786 static PyObject *_wrap_Locale_Init2(PyObject *, PyObject *args, PyObject *kwargs) {
11787 PyObject *resultobj;
11788 wxLocale *arg1 = (wxLocale *) 0 ;
11789 int arg2 = (int) wxLANGUAGE_DEFAULT ;
11790 int arg3 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11791 bool result;
11792 PyObject * obj0 = 0 ;
11793 PyObject * obj1 = 0 ;
11794 PyObject * obj2 = 0 ;
11795 char *kwnames[] = {
11796 (char *) "self",(char *) "language",(char *) "flags", NULL
11797 };
11798
11799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Locale_Init2",kwnames,&obj0,&obj1,&obj2)) goto fail;
11800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11801 if (SWIG_arg_fail(1)) SWIG_fail;
11802 if (obj1) {
11803 {
11804 arg2 = (int)(SWIG_As_int(obj1));
11805 if (SWIG_arg_fail(2)) SWIG_fail;
11806 }
11807 }
11808 if (obj2) {
11809 {
11810 arg3 = (int)(SWIG_As_int(obj2));
11811 if (SWIG_arg_fail(3)) SWIG_fail;
11812 }
11813 }
11814 {
11815 PyThreadState* __tstate = wxPyBeginAllowThreads();
11816 result = (bool)wxLocale_Init2(arg1,arg2,arg3);
11817
11818 wxPyEndAllowThreads(__tstate);
11819 if (PyErr_Occurred()) SWIG_fail;
11820 }
11821 {
11822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11823 }
11824 return resultobj;
11825 fail:
11826 return NULL;
11827 }
11828
11829
11830 static PyObject *_wrap_Locale_GetSystemLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11831 PyObject *resultobj;
11832 int result;
11833 char *kwnames[] = {
11834 NULL
11835 };
11836
11837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemLanguage",kwnames)) goto fail;
11838 {
11839 PyThreadState* __tstate = wxPyBeginAllowThreads();
11840 result = (int)wxLocale::GetSystemLanguage();
11841
11842 wxPyEndAllowThreads(__tstate);
11843 if (PyErr_Occurred()) SWIG_fail;
11844 }
11845 {
11846 resultobj = SWIG_From_int((int)(result));
11847 }
11848 return resultobj;
11849 fail:
11850 return NULL;
11851 }
11852
11853
11854 static PyObject *_wrap_Locale_GetSystemEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11855 PyObject *resultobj;
11856 wxFontEncoding result;
11857 char *kwnames[] = {
11858 NULL
11859 };
11860
11861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncoding",kwnames)) goto fail;
11862 {
11863 PyThreadState* __tstate = wxPyBeginAllowThreads();
11864 result = (wxFontEncoding)wxLocale::GetSystemEncoding();
11865
11866 wxPyEndAllowThreads(__tstate);
11867 if (PyErr_Occurred()) SWIG_fail;
11868 }
11869 resultobj = SWIG_From_int((result));
11870 return resultobj;
11871 fail:
11872 return NULL;
11873 }
11874
11875
11876 static PyObject *_wrap_Locale_GetSystemEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
11877 PyObject *resultobj;
11878 wxString result;
11879 char *kwnames[] = {
11880 NULL
11881 };
11882
11883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncodingName",kwnames)) goto fail;
11884 {
11885 PyThreadState* __tstate = wxPyBeginAllowThreads();
11886 result = wxLocale::GetSystemEncodingName();
11887
11888 wxPyEndAllowThreads(__tstate);
11889 if (PyErr_Occurred()) SWIG_fail;
11890 }
11891 {
11892 #if wxUSE_UNICODE
11893 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11894 #else
11895 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11896 #endif
11897 }
11898 return resultobj;
11899 fail:
11900 return NULL;
11901 }
11902
11903
11904 static PyObject *_wrap_Locale_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11905 PyObject *resultobj;
11906 wxLocale *arg1 = (wxLocale *) 0 ;
11907 bool result;
11908 PyObject * obj0 = 0 ;
11909 char *kwnames[] = {
11910 (char *) "self", NULL
11911 };
11912
11913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_IsOk",kwnames,&obj0)) goto fail;
11914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11915 if (SWIG_arg_fail(1)) SWIG_fail;
11916 {
11917 PyThreadState* __tstate = wxPyBeginAllowThreads();
11918 result = (bool)((wxLocale const *)arg1)->IsOk();
11919
11920 wxPyEndAllowThreads(__tstate);
11921 if (PyErr_Occurred()) SWIG_fail;
11922 }
11923 {
11924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11925 }
11926 return resultobj;
11927 fail:
11928 return NULL;
11929 }
11930
11931
11932 static PyObject *_wrap_Locale_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11933 PyObject *resultobj;
11934 wxLocale *arg1 = (wxLocale *) 0 ;
11935 wxString result;
11936 PyObject * obj0 = 0 ;
11937 char *kwnames[] = {
11938 (char *) "self", NULL
11939 };
11940
11941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLocale",kwnames,&obj0)) goto fail;
11942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11943 if (SWIG_arg_fail(1)) SWIG_fail;
11944 {
11945 PyThreadState* __tstate = wxPyBeginAllowThreads();
11946 result = ((wxLocale const *)arg1)->GetLocale();
11947
11948 wxPyEndAllowThreads(__tstate);
11949 if (PyErr_Occurred()) SWIG_fail;
11950 }
11951 {
11952 #if wxUSE_UNICODE
11953 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11954 #else
11955 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11956 #endif
11957 }
11958 return resultobj;
11959 fail:
11960 return NULL;
11961 }
11962
11963
11964 static PyObject *_wrap_Locale_GetLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11965 PyObject *resultobj;
11966 wxLocale *arg1 = (wxLocale *) 0 ;
11967 int result;
11968 PyObject * obj0 = 0 ;
11969 char *kwnames[] = {
11970 (char *) "self", NULL
11971 };
11972
11973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguage",kwnames,&obj0)) goto fail;
11974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11975 if (SWIG_arg_fail(1)) SWIG_fail;
11976 {
11977 PyThreadState* __tstate = wxPyBeginAllowThreads();
11978 result = (int)((wxLocale const *)arg1)->GetLanguage();
11979
11980 wxPyEndAllowThreads(__tstate);
11981 if (PyErr_Occurred()) SWIG_fail;
11982 }
11983 {
11984 resultobj = SWIG_From_int((int)(result));
11985 }
11986 return resultobj;
11987 fail:
11988 return NULL;
11989 }
11990
11991
11992 static PyObject *_wrap_Locale_GetSysName(PyObject *, PyObject *args, PyObject *kwargs) {
11993 PyObject *resultobj;
11994 wxLocale *arg1 = (wxLocale *) 0 ;
11995 wxString result;
11996 PyObject * obj0 = 0 ;
11997 char *kwnames[] = {
11998 (char *) "self", NULL
11999 };
12000
12001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetSysName",kwnames,&obj0)) goto fail;
12002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12003 if (SWIG_arg_fail(1)) SWIG_fail;
12004 {
12005 PyThreadState* __tstate = wxPyBeginAllowThreads();
12006 result = ((wxLocale const *)arg1)->GetSysName();
12007
12008 wxPyEndAllowThreads(__tstate);
12009 if (PyErr_Occurred()) SWIG_fail;
12010 }
12011 {
12012 #if wxUSE_UNICODE
12013 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12014 #else
12015 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12016 #endif
12017 }
12018 return resultobj;
12019 fail:
12020 return NULL;
12021 }
12022
12023
12024 static PyObject *_wrap_Locale_GetCanonicalName(PyObject *, PyObject *args, PyObject *kwargs) {
12025 PyObject *resultobj;
12026 wxLocale *arg1 = (wxLocale *) 0 ;
12027 wxString result;
12028 PyObject * obj0 = 0 ;
12029 char *kwnames[] = {
12030 (char *) "self", NULL
12031 };
12032
12033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetCanonicalName",kwnames,&obj0)) goto fail;
12034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12035 if (SWIG_arg_fail(1)) SWIG_fail;
12036 {
12037 PyThreadState* __tstate = wxPyBeginAllowThreads();
12038 result = ((wxLocale const *)arg1)->GetCanonicalName();
12039
12040 wxPyEndAllowThreads(__tstate);
12041 if (PyErr_Occurred()) SWIG_fail;
12042 }
12043 {
12044 #if wxUSE_UNICODE
12045 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12046 #else
12047 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12048 #endif
12049 }
12050 return resultobj;
12051 fail:
12052 return NULL;
12053 }
12054
12055
12056 static PyObject *_wrap_Locale_AddCatalogLookupPathPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
12057 PyObject *resultobj;
12058 wxString *arg1 = 0 ;
12059 bool temp1 = false ;
12060 PyObject * obj0 = 0 ;
12061 char *kwnames[] = {
12062 (char *) "prefix", NULL
12063 };
12064
12065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddCatalogLookupPathPrefix",kwnames,&obj0)) goto fail;
12066 {
12067 arg1 = wxString_in_helper(obj0);
12068 if (arg1 == NULL) SWIG_fail;
12069 temp1 = true;
12070 }
12071 {
12072 PyThreadState* __tstate = wxPyBeginAllowThreads();
12073 wxLocale::AddCatalogLookupPathPrefix((wxString const &)*arg1);
12074
12075 wxPyEndAllowThreads(__tstate);
12076 if (PyErr_Occurred()) SWIG_fail;
12077 }
12078 Py_INCREF(Py_None); resultobj = Py_None;
12079 {
12080 if (temp1)
12081 delete arg1;
12082 }
12083 return resultobj;
12084 fail:
12085 {
12086 if (temp1)
12087 delete arg1;
12088 }
12089 return NULL;
12090 }
12091
12092
12093 static PyObject *_wrap_Locale_AddCatalog(PyObject *, PyObject *args, PyObject *kwargs) {
12094 PyObject *resultobj;
12095 wxLocale *arg1 = (wxLocale *) 0 ;
12096 wxString *arg2 = 0 ;
12097 bool result;
12098 bool temp2 = false ;
12099 PyObject * obj0 = 0 ;
12100 PyObject * obj1 = 0 ;
12101 char *kwnames[] = {
12102 (char *) "self",(char *) "szDomain", NULL
12103 };
12104
12105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_AddCatalog",kwnames,&obj0,&obj1)) goto fail;
12106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12107 if (SWIG_arg_fail(1)) SWIG_fail;
12108 {
12109 arg2 = wxString_in_helper(obj1);
12110 if (arg2 == NULL) SWIG_fail;
12111 temp2 = true;
12112 }
12113 {
12114 PyThreadState* __tstate = wxPyBeginAllowThreads();
12115 result = (bool)(arg1)->AddCatalog((wxString const &)*arg2);
12116
12117 wxPyEndAllowThreads(__tstate);
12118 if (PyErr_Occurred()) SWIG_fail;
12119 }
12120 {
12121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12122 }
12123 {
12124 if (temp2)
12125 delete arg2;
12126 }
12127 return resultobj;
12128 fail:
12129 {
12130 if (temp2)
12131 delete arg2;
12132 }
12133 return NULL;
12134 }
12135
12136
12137 static PyObject *_wrap_Locale_IsLoaded(PyObject *, PyObject *args, PyObject *kwargs) {
12138 PyObject *resultobj;
12139 wxLocale *arg1 = (wxLocale *) 0 ;
12140 wxString *arg2 = 0 ;
12141 bool result;
12142 bool temp2 = false ;
12143 PyObject * obj0 = 0 ;
12144 PyObject * obj1 = 0 ;
12145 char *kwnames[] = {
12146 (char *) "self",(char *) "szDomain", NULL
12147 };
12148
12149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_IsLoaded",kwnames,&obj0,&obj1)) goto fail;
12150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12151 if (SWIG_arg_fail(1)) SWIG_fail;
12152 {
12153 arg2 = wxString_in_helper(obj1);
12154 if (arg2 == NULL) SWIG_fail;
12155 temp2 = true;
12156 }
12157 {
12158 PyThreadState* __tstate = wxPyBeginAllowThreads();
12159 result = (bool)((wxLocale const *)arg1)->IsLoaded((wxString const &)*arg2);
12160
12161 wxPyEndAllowThreads(__tstate);
12162 if (PyErr_Occurred()) SWIG_fail;
12163 }
12164 {
12165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12166 }
12167 {
12168 if (temp2)
12169 delete arg2;
12170 }
12171 return resultobj;
12172 fail:
12173 {
12174 if (temp2)
12175 delete arg2;
12176 }
12177 return NULL;
12178 }
12179
12180
12181 static PyObject *_wrap_Locale_GetLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
12182 PyObject *resultobj;
12183 int arg1 ;
12184 wxLanguageInfo *result;
12185 PyObject * obj0 = 0 ;
12186 char *kwnames[] = {
12187 (char *) "lang", NULL
12188 };
12189
12190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageInfo",kwnames,&obj0)) goto fail;
12191 {
12192 arg1 = (int)(SWIG_As_int(obj0));
12193 if (SWIG_arg_fail(1)) SWIG_fail;
12194 }
12195 {
12196 PyThreadState* __tstate = wxPyBeginAllowThreads();
12197 result = (wxLanguageInfo *)wxLocale::GetLanguageInfo(arg1);
12198
12199 wxPyEndAllowThreads(__tstate);
12200 if (PyErr_Occurred()) SWIG_fail;
12201 }
12202 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
12203 return resultobj;
12204 fail:
12205 return NULL;
12206 }
12207
12208
12209 static PyObject *_wrap_Locale_GetLanguageName(PyObject *, PyObject *args, PyObject *kwargs) {
12210 PyObject *resultobj;
12211 int arg1 ;
12212 wxString result;
12213 PyObject * obj0 = 0 ;
12214 char *kwnames[] = {
12215 (char *) "lang", NULL
12216 };
12217
12218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageName",kwnames,&obj0)) goto fail;
12219 {
12220 arg1 = (int)(SWIG_As_int(obj0));
12221 if (SWIG_arg_fail(1)) SWIG_fail;
12222 }
12223 {
12224 PyThreadState* __tstate = wxPyBeginAllowThreads();
12225 result = wxLocale::GetLanguageName(arg1);
12226
12227 wxPyEndAllowThreads(__tstate);
12228 if (PyErr_Occurred()) SWIG_fail;
12229 }
12230 {
12231 #if wxUSE_UNICODE
12232 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12233 #else
12234 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12235 #endif
12236 }
12237 return resultobj;
12238 fail:
12239 return NULL;
12240 }
12241
12242
12243 static PyObject *_wrap_Locale_FindLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
12244 PyObject *resultobj;
12245 wxString *arg1 = 0 ;
12246 wxLanguageInfo *result;
12247 bool temp1 = false ;
12248 PyObject * obj0 = 0 ;
12249 char *kwnames[] = {
12250 (char *) "locale", NULL
12251 };
12252
12253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_FindLanguageInfo",kwnames,&obj0)) goto fail;
12254 {
12255 arg1 = wxString_in_helper(obj0);
12256 if (arg1 == NULL) SWIG_fail;
12257 temp1 = true;
12258 }
12259 {
12260 PyThreadState* __tstate = wxPyBeginAllowThreads();
12261 result = (wxLanguageInfo *)wxLocale::FindLanguageInfo((wxString const &)*arg1);
12262
12263 wxPyEndAllowThreads(__tstate);
12264 if (PyErr_Occurred()) SWIG_fail;
12265 }
12266 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
12267 {
12268 if (temp1)
12269 delete arg1;
12270 }
12271 return resultobj;
12272 fail:
12273 {
12274 if (temp1)
12275 delete arg1;
12276 }
12277 return NULL;
12278 }
12279
12280
12281 static PyObject *_wrap_Locale_AddLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
12282 PyObject *resultobj;
12283 wxLanguageInfo *arg1 = 0 ;
12284 PyObject * obj0 = 0 ;
12285 char *kwnames[] = {
12286 (char *) "info", NULL
12287 };
12288
12289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddLanguage",kwnames,&obj0)) goto fail;
12290 {
12291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
12292 if (SWIG_arg_fail(1)) SWIG_fail;
12293 if (arg1 == NULL) {
12294 SWIG_null_ref("wxLanguageInfo");
12295 }
12296 if (SWIG_arg_fail(1)) SWIG_fail;
12297 }
12298 {
12299 PyThreadState* __tstate = wxPyBeginAllowThreads();
12300 wxLocale::AddLanguage((wxLanguageInfo const &)*arg1);
12301
12302 wxPyEndAllowThreads(__tstate);
12303 if (PyErr_Occurred()) SWIG_fail;
12304 }
12305 Py_INCREF(Py_None); resultobj = Py_None;
12306 return resultobj;
12307 fail:
12308 return NULL;
12309 }
12310
12311
12312 static PyObject *_wrap_Locale_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
12313 PyObject *resultobj;
12314 wxLocale *arg1 = (wxLocale *) 0 ;
12315 wxString *arg2 = 0 ;
12316 wxString const &arg3_defvalue = wxPyEmptyString ;
12317 wxString *arg3 = (wxString *) &arg3_defvalue ;
12318 wxString result;
12319 bool temp2 = false ;
12320 bool temp3 = false ;
12321 PyObject * obj0 = 0 ;
12322 PyObject * obj1 = 0 ;
12323 PyObject * obj2 = 0 ;
12324 char *kwnames[] = {
12325 (char *) "self",(char *) "szOrigString",(char *) "szDomain", NULL
12326 };
12327
12328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Locale_GetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
12329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12330 if (SWIG_arg_fail(1)) SWIG_fail;
12331 {
12332 arg2 = wxString_in_helper(obj1);
12333 if (arg2 == NULL) SWIG_fail;
12334 temp2 = true;
12335 }
12336 if (obj2) {
12337 {
12338 arg3 = wxString_in_helper(obj2);
12339 if (arg3 == NULL) SWIG_fail;
12340 temp3 = true;
12341 }
12342 }
12343 {
12344 PyThreadState* __tstate = wxPyBeginAllowThreads();
12345 result = ((wxLocale const *)arg1)->GetString((wxString const &)*arg2,(wxString const &)*arg3);
12346
12347 wxPyEndAllowThreads(__tstate);
12348 if (PyErr_Occurred()) SWIG_fail;
12349 }
12350 {
12351 #if wxUSE_UNICODE
12352 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12353 #else
12354 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12355 #endif
12356 }
12357 {
12358 if (temp2)
12359 delete arg2;
12360 }
12361 {
12362 if (temp3)
12363 delete arg3;
12364 }
12365 return resultobj;
12366 fail:
12367 {
12368 if (temp2)
12369 delete arg2;
12370 }
12371 {
12372 if (temp3)
12373 delete arg3;
12374 }
12375 return NULL;
12376 }
12377
12378
12379 static PyObject *_wrap_Locale_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
12380 PyObject *resultobj;
12381 wxLocale *arg1 = (wxLocale *) 0 ;
12382 wxString *result;
12383 PyObject * obj0 = 0 ;
12384 char *kwnames[] = {
12385 (char *) "self", NULL
12386 };
12387
12388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetName",kwnames,&obj0)) goto fail;
12389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12390 if (SWIG_arg_fail(1)) SWIG_fail;
12391 {
12392 PyThreadState* __tstate = wxPyBeginAllowThreads();
12393 {
12394 wxString const &_result_ref = ((wxLocale const *)arg1)->GetName();
12395 result = (wxString *) &_result_ref;
12396 }
12397
12398 wxPyEndAllowThreads(__tstate);
12399 if (PyErr_Occurred()) SWIG_fail;
12400 }
12401 {
12402 #if wxUSE_UNICODE
12403 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12404 #else
12405 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12406 #endif
12407 }
12408 return resultobj;
12409 fail:
12410 return NULL;
12411 }
12412
12413
12414 static PyObject * Locale_swigregister(PyObject *, PyObject *args) {
12415 PyObject *obj;
12416 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12417 SWIG_TypeClientData(SWIGTYPE_p_wxLocale, obj);
12418 Py_INCREF(obj);
12419 return Py_BuildValue((char *)"");
12420 }
12421 static PyObject *_wrap_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
12422 PyObject *resultobj;
12423 wxLocale *result;
12424 char *kwnames[] = {
12425 NULL
12426 };
12427
12428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocale",kwnames)) goto fail;
12429 {
12430 PyThreadState* __tstate = wxPyBeginAllowThreads();
12431 result = (wxLocale *)wxGetLocale();
12432
12433 wxPyEndAllowThreads(__tstate);
12434 if (PyErr_Occurred()) SWIG_fail;
12435 }
12436 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 0);
12437 return resultobj;
12438 fail:
12439 return NULL;
12440 }
12441
12442
12443 static PyObject *_wrap_GetTranslation__SWIG_0(PyObject *, PyObject *args) {
12444 PyObject *resultobj;
12445 wxString *arg1 = 0 ;
12446 wxString result;
12447 bool temp1 = false ;
12448 PyObject * obj0 = 0 ;
12449
12450 if(!PyArg_ParseTuple(args,(char *)"O:GetTranslation",&obj0)) goto fail;
12451 {
12452 arg1 = wxString_in_helper(obj0);
12453 if (arg1 == NULL) SWIG_fail;
12454 temp1 = true;
12455 }
12456 {
12457 PyThreadState* __tstate = wxPyBeginAllowThreads();
12458 result = wxGetTranslation((wxString const &)*arg1);
12459
12460 wxPyEndAllowThreads(__tstate);
12461 if (PyErr_Occurred()) SWIG_fail;
12462 }
12463 {
12464 #if wxUSE_UNICODE
12465 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12466 #else
12467 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12468 #endif
12469 }
12470 {
12471 if (temp1)
12472 delete arg1;
12473 }
12474 return resultobj;
12475 fail:
12476 {
12477 if (temp1)
12478 delete arg1;
12479 }
12480 return NULL;
12481 }
12482
12483
12484 static PyObject *_wrap_GetTranslation__SWIG_1(PyObject *, PyObject *args) {
12485 PyObject *resultobj;
12486 wxString *arg1 = 0 ;
12487 wxString *arg2 = 0 ;
12488 size_t arg3 ;
12489 wxString result;
12490 bool temp1 = false ;
12491 bool temp2 = false ;
12492 PyObject * obj0 = 0 ;
12493 PyObject * obj1 = 0 ;
12494 PyObject * obj2 = 0 ;
12495
12496 if(!PyArg_ParseTuple(args,(char *)"OOO:GetTranslation",&obj0,&obj1,&obj2)) goto fail;
12497 {
12498 arg1 = wxString_in_helper(obj0);
12499 if (arg1 == NULL) SWIG_fail;
12500 temp1 = true;
12501 }
12502 {
12503 arg2 = wxString_in_helper(obj1);
12504 if (arg2 == NULL) SWIG_fail;
12505 temp2 = true;
12506 }
12507 {
12508 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
12509 if (SWIG_arg_fail(3)) SWIG_fail;
12510 }
12511 {
12512 PyThreadState* __tstate = wxPyBeginAllowThreads();
12513 result = wxGetTranslation((wxString const &)*arg1,(wxString const &)*arg2,arg3);
12514
12515 wxPyEndAllowThreads(__tstate);
12516 if (PyErr_Occurred()) SWIG_fail;
12517 }
12518 {
12519 #if wxUSE_UNICODE
12520 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12521 #else
12522 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12523 #endif
12524 }
12525 {
12526 if (temp1)
12527 delete arg1;
12528 }
12529 {
12530 if (temp2)
12531 delete arg2;
12532 }
12533 return resultobj;
12534 fail:
12535 {
12536 if (temp1)
12537 delete arg1;
12538 }
12539 {
12540 if (temp2)
12541 delete arg2;
12542 }
12543 return NULL;
12544 }
12545
12546
12547 static PyObject *_wrap_GetTranslation(PyObject *self, PyObject *args) {
12548 int argc;
12549 PyObject *argv[4];
12550 int ii;
12551
12552 argc = PyObject_Length(args);
12553 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
12554 argv[ii] = PyTuple_GetItem(args,ii);
12555 }
12556 if (argc == 1) {
12557 int _v;
12558 {
12559 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12560 }
12561 if (_v) {
12562 return _wrap_GetTranslation__SWIG_0(self,args);
12563 }
12564 }
12565 if (argc == 3) {
12566 int _v;
12567 {
12568 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12569 }
12570 if (_v) {
12571 {
12572 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
12573 }
12574 if (_v) {
12575 _v = SWIG_Check_unsigned_SS_long(argv[2]);
12576 if (_v) {
12577 return _wrap_GetTranslation__SWIG_1(self,args);
12578 }
12579 }
12580 }
12581 }
12582
12583 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GetTranslation'");
12584 return NULL;
12585 }
12586
12587
12588 static PyObject *_wrap_new_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
12589 PyObject *resultobj;
12590 wxEncodingConverter *result;
12591 char *kwnames[] = {
12592 NULL
12593 };
12594
12595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EncodingConverter",kwnames)) goto fail;
12596 {
12597 PyThreadState* __tstate = wxPyBeginAllowThreads();
12598 result = (wxEncodingConverter *)new wxEncodingConverter();
12599
12600 wxPyEndAllowThreads(__tstate);
12601 if (PyErr_Occurred()) SWIG_fail;
12602 }
12603 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEncodingConverter, 1);
12604 return resultobj;
12605 fail:
12606 return NULL;
12607 }
12608
12609
12610 static PyObject *_wrap_delete_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
12611 PyObject *resultobj;
12612 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12613 PyObject * obj0 = 0 ;
12614 char *kwnames[] = {
12615 (char *) "self", NULL
12616 };
12617
12618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EncodingConverter",kwnames,&obj0)) goto fail;
12619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12620 if (SWIG_arg_fail(1)) SWIG_fail;
12621 {
12622 PyThreadState* __tstate = wxPyBeginAllowThreads();
12623 delete arg1;
12624
12625 wxPyEndAllowThreads(__tstate);
12626 if (PyErr_Occurred()) SWIG_fail;
12627 }
12628 Py_INCREF(Py_None); resultobj = Py_None;
12629 return resultobj;
12630 fail:
12631 return NULL;
12632 }
12633
12634
12635 static PyObject *_wrap_EncodingConverter_Init(PyObject *, PyObject *args, PyObject *kwargs) {
12636 PyObject *resultobj;
12637 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12638 wxFontEncoding arg2 ;
12639 wxFontEncoding arg3 ;
12640 int arg4 = (int) wxCONVERT_STRICT ;
12641 bool result;
12642 PyObject * obj0 = 0 ;
12643 PyObject * obj1 = 0 ;
12644 PyObject * obj2 = 0 ;
12645 PyObject * obj3 = 0 ;
12646 char *kwnames[] = {
12647 (char *) "self",(char *) "input_enc",(char *) "output_enc",(char *) "method", NULL
12648 };
12649
12650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:EncodingConverter_Init",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12652 if (SWIG_arg_fail(1)) SWIG_fail;
12653 {
12654 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12655 if (SWIG_arg_fail(2)) SWIG_fail;
12656 }
12657 {
12658 arg3 = (wxFontEncoding)(SWIG_As_int(obj2));
12659 if (SWIG_arg_fail(3)) SWIG_fail;
12660 }
12661 if (obj3) {
12662 {
12663 arg4 = (int)(SWIG_As_int(obj3));
12664 if (SWIG_arg_fail(4)) SWIG_fail;
12665 }
12666 }
12667 {
12668 PyThreadState* __tstate = wxPyBeginAllowThreads();
12669 result = (bool)(arg1)->Init((wxFontEncoding )arg2,(wxFontEncoding )arg3,arg4);
12670
12671 wxPyEndAllowThreads(__tstate);
12672 if (PyErr_Occurred()) SWIG_fail;
12673 }
12674 {
12675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12676 }
12677 return resultobj;
12678 fail:
12679 return NULL;
12680 }
12681
12682
12683 static PyObject *_wrap_EncodingConverter_Convert(PyObject *, PyObject *args, PyObject *kwargs) {
12684 PyObject *resultobj;
12685 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12686 wxString *arg2 = 0 ;
12687 wxString result;
12688 bool temp2 = false ;
12689 PyObject * obj0 = 0 ;
12690 PyObject * obj1 = 0 ;
12691 char *kwnames[] = {
12692 (char *) "self",(char *) "input", NULL
12693 };
12694
12695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_Convert",kwnames,&obj0,&obj1)) goto fail;
12696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12697 if (SWIG_arg_fail(1)) SWIG_fail;
12698 {
12699 arg2 = wxString_in_helper(obj1);
12700 if (arg2 == NULL) SWIG_fail;
12701 temp2 = true;
12702 }
12703 {
12704 PyThreadState* __tstate = wxPyBeginAllowThreads();
12705 result = (arg1)->Convert((wxString const &)*arg2);
12706
12707 wxPyEndAllowThreads(__tstate);
12708 if (PyErr_Occurred()) SWIG_fail;
12709 }
12710 {
12711 #if wxUSE_UNICODE
12712 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12713 #else
12714 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12715 #endif
12716 }
12717 {
12718 if (temp2)
12719 delete arg2;
12720 }
12721 return resultobj;
12722 fail:
12723 {
12724 if (temp2)
12725 delete arg2;
12726 }
12727 return NULL;
12728 }
12729
12730
12731 static PyObject *_wrap_EncodingConverter_GetPlatformEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12732 PyObject *resultobj;
12733 wxFontEncoding arg1 ;
12734 int arg2 = (int) wxPLATFORM_CURRENT ;
12735 wxFontEncodingArray result;
12736 PyObject * obj0 = 0 ;
12737 PyObject * obj1 = 0 ;
12738 char *kwnames[] = {
12739 (char *) "enc",(char *) "platform", NULL
12740 };
12741
12742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EncodingConverter_GetPlatformEquivalents",kwnames,&obj0,&obj1)) goto fail;
12743 {
12744 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12745 if (SWIG_arg_fail(1)) SWIG_fail;
12746 }
12747 if (obj1) {
12748 {
12749 arg2 = (int)(SWIG_As_int(obj1));
12750 if (SWIG_arg_fail(2)) SWIG_fail;
12751 }
12752 }
12753 {
12754 PyThreadState* __tstate = wxPyBeginAllowThreads();
12755 result = wxEncodingConverter::GetPlatformEquivalents((wxFontEncoding )arg1,arg2);
12756
12757 wxPyEndAllowThreads(__tstate);
12758 if (PyErr_Occurred()) SWIG_fail;
12759 }
12760 {
12761 resultobj = PyList_New(0);
12762 for (size_t i=0; i < (&result)->GetCount(); i++) {
12763 PyObject* number = PyInt_FromLong((&result)->Item(i));
12764 PyList_Append(resultobj, number);
12765 Py_DECREF(number);
12766 }
12767 }
12768 return resultobj;
12769 fail:
12770 return NULL;
12771 }
12772
12773
12774 static PyObject *_wrap_EncodingConverter_GetAllEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12775 PyObject *resultobj;
12776 wxFontEncoding arg1 ;
12777 wxFontEncodingArray result;
12778 PyObject * obj0 = 0 ;
12779 char *kwnames[] = {
12780 (char *) "enc", NULL
12781 };
12782
12783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EncodingConverter_GetAllEquivalents",kwnames,&obj0)) goto fail;
12784 {
12785 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12786 if (SWIG_arg_fail(1)) SWIG_fail;
12787 }
12788 {
12789 PyThreadState* __tstate = wxPyBeginAllowThreads();
12790 result = wxEncodingConverter::GetAllEquivalents((wxFontEncoding )arg1);
12791
12792 wxPyEndAllowThreads(__tstate);
12793 if (PyErr_Occurred()) SWIG_fail;
12794 }
12795 {
12796 resultobj = PyList_New(0);
12797 for (size_t i=0; i < (&result)->GetCount(); i++) {
12798 PyObject* number = PyInt_FromLong((&result)->Item(i));
12799 PyList_Append(resultobj, number);
12800 Py_DECREF(number);
12801 }
12802 }
12803 return resultobj;
12804 fail:
12805 return NULL;
12806 }
12807
12808
12809 static PyObject *_wrap_EncodingConverter_CanConvert(PyObject *, PyObject *args, PyObject *kwargs) {
12810 PyObject *resultobj;
12811 wxFontEncoding arg1 ;
12812 wxFontEncoding arg2 ;
12813 bool result;
12814 PyObject * obj0 = 0 ;
12815 PyObject * obj1 = 0 ;
12816 char *kwnames[] = {
12817 (char *) "encIn",(char *) "encOut", NULL
12818 };
12819
12820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_CanConvert",kwnames,&obj0,&obj1)) goto fail;
12821 {
12822 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12823 if (SWIG_arg_fail(1)) SWIG_fail;
12824 }
12825 {
12826 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12827 if (SWIG_arg_fail(2)) SWIG_fail;
12828 }
12829 {
12830 PyThreadState* __tstate = wxPyBeginAllowThreads();
12831 result = (bool)wxEncodingConverter::CanConvert((wxFontEncoding )arg1,(wxFontEncoding )arg2);
12832
12833 wxPyEndAllowThreads(__tstate);
12834 if (PyErr_Occurred()) SWIG_fail;
12835 }
12836 {
12837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12838 }
12839 return resultobj;
12840 fail:
12841 return NULL;
12842 }
12843
12844
12845 static PyObject * EncodingConverter_swigregister(PyObject *, PyObject *args) {
12846 PyObject *obj;
12847 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12848 SWIG_TypeClientData(SWIGTYPE_p_wxEncodingConverter, obj);
12849 Py_INCREF(obj);
12850 return Py_BuildValue((char *)"");
12851 }
12852 static PyObject *_wrap_delete_DC(PyObject *, PyObject *args, PyObject *kwargs) {
12853 PyObject *resultobj;
12854 wxDC *arg1 = (wxDC *) 0 ;
12855 PyObject * obj0 = 0 ;
12856 char *kwnames[] = {
12857 (char *) "self", NULL
12858 };
12859
12860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DC",kwnames,&obj0)) goto fail;
12861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12862 if (SWIG_arg_fail(1)) SWIG_fail;
12863 {
12864 PyThreadState* __tstate = wxPyBeginAllowThreads();
12865 delete arg1;
12866
12867 wxPyEndAllowThreads(__tstate);
12868 if (PyErr_Occurred()) SWIG_fail;
12869 }
12870 Py_INCREF(Py_None); resultobj = Py_None;
12871 return resultobj;
12872 fail:
12873 return NULL;
12874 }
12875
12876
12877 static PyObject *_wrap_DC_BeginDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12878 PyObject *resultobj;
12879 wxDC *arg1 = (wxDC *) 0 ;
12880 PyObject * obj0 = 0 ;
12881 char *kwnames[] = {
12882 (char *) "self", NULL
12883 };
12884
12885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_BeginDrawing",kwnames,&obj0)) goto fail;
12886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12887 if (SWIG_arg_fail(1)) SWIG_fail;
12888 {
12889 PyThreadState* __tstate = wxPyBeginAllowThreads();
12890 (arg1)->BeginDrawing();
12891
12892 wxPyEndAllowThreads(__tstate);
12893 if (PyErr_Occurred()) SWIG_fail;
12894 }
12895 Py_INCREF(Py_None); resultobj = Py_None;
12896 return resultobj;
12897 fail:
12898 return NULL;
12899 }
12900
12901
12902 static PyObject *_wrap_DC_EndDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12903 PyObject *resultobj;
12904 wxDC *arg1 = (wxDC *) 0 ;
12905 PyObject * obj0 = 0 ;
12906 char *kwnames[] = {
12907 (char *) "self", NULL
12908 };
12909
12910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDrawing",kwnames,&obj0)) goto fail;
12911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12912 if (SWIG_arg_fail(1)) SWIG_fail;
12913 {
12914 PyThreadState* __tstate = wxPyBeginAllowThreads();
12915 (arg1)->EndDrawing();
12916
12917 wxPyEndAllowThreads(__tstate);
12918 if (PyErr_Occurred()) SWIG_fail;
12919 }
12920 Py_INCREF(Py_None); resultobj = Py_None;
12921 return resultobj;
12922 fail:
12923 return NULL;
12924 }
12925
12926
12927 static PyObject *_wrap_DC_FloodFill(PyObject *, PyObject *args, PyObject *kwargs) {
12928 PyObject *resultobj;
12929 wxDC *arg1 = (wxDC *) 0 ;
12930 int arg2 ;
12931 int arg3 ;
12932 wxColour *arg4 = 0 ;
12933 int arg5 = (int) wxFLOOD_SURFACE ;
12934 bool result;
12935 wxColour temp4 ;
12936 PyObject * obj0 = 0 ;
12937 PyObject * obj1 = 0 ;
12938 PyObject * obj2 = 0 ;
12939 PyObject * obj3 = 0 ;
12940 PyObject * obj4 = 0 ;
12941 char *kwnames[] = {
12942 (char *) "self",(char *) "x",(char *) "y",(char *) "col",(char *) "style", NULL
12943 };
12944
12945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_FloodFill",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12947 if (SWIG_arg_fail(1)) SWIG_fail;
12948 {
12949 arg2 = (int)(SWIG_As_int(obj1));
12950 if (SWIG_arg_fail(2)) SWIG_fail;
12951 }
12952 {
12953 arg3 = (int)(SWIG_As_int(obj2));
12954 if (SWIG_arg_fail(3)) SWIG_fail;
12955 }
12956 {
12957 arg4 = &temp4;
12958 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
12959 }
12960 if (obj4) {
12961 {
12962 arg5 = (int)(SWIG_As_int(obj4));
12963 if (SWIG_arg_fail(5)) SWIG_fail;
12964 }
12965 }
12966 {
12967 PyThreadState* __tstate = wxPyBeginAllowThreads();
12968 result = (bool)(arg1)->FloodFill(arg2,arg3,(wxColour const &)*arg4,arg5);
12969
12970 wxPyEndAllowThreads(__tstate);
12971 if (PyErr_Occurred()) SWIG_fail;
12972 }
12973 {
12974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12975 }
12976 return resultobj;
12977 fail:
12978 return NULL;
12979 }
12980
12981
12982 static PyObject *_wrap_DC_FloodFillPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12983 PyObject *resultobj;
12984 wxDC *arg1 = (wxDC *) 0 ;
12985 wxPoint *arg2 = 0 ;
12986 wxColour *arg3 = 0 ;
12987 int arg4 = (int) wxFLOOD_SURFACE ;
12988 bool result;
12989 wxPoint temp2 ;
12990 wxColour temp3 ;
12991 PyObject * obj0 = 0 ;
12992 PyObject * obj1 = 0 ;
12993 PyObject * obj2 = 0 ;
12994 PyObject * obj3 = 0 ;
12995 char *kwnames[] = {
12996 (char *) "self",(char *) "pt",(char *) "col",(char *) "style", NULL
12997 };
12998
12999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_FloodFillPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13001 if (SWIG_arg_fail(1)) SWIG_fail;
13002 {
13003 arg2 = &temp2;
13004 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13005 }
13006 {
13007 arg3 = &temp3;
13008 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
13009 }
13010 if (obj3) {
13011 {
13012 arg4 = (int)(SWIG_As_int(obj3));
13013 if (SWIG_arg_fail(4)) SWIG_fail;
13014 }
13015 }
13016 {
13017 PyThreadState* __tstate = wxPyBeginAllowThreads();
13018 result = (bool)(arg1)->FloodFill((wxPoint const &)*arg2,(wxColour const &)*arg3,arg4);
13019
13020 wxPyEndAllowThreads(__tstate);
13021 if (PyErr_Occurred()) SWIG_fail;
13022 }
13023 {
13024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13025 }
13026 return resultobj;
13027 fail:
13028 return NULL;
13029 }
13030
13031
13032 static PyObject *_wrap_DC_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
13033 PyObject *resultobj;
13034 wxDC *arg1 = (wxDC *) 0 ;
13035 int arg2 ;
13036 int arg3 ;
13037 wxColour result;
13038 PyObject * obj0 = 0 ;
13039 PyObject * obj1 = 0 ;
13040 PyObject * obj2 = 0 ;
13041 char *kwnames[] = {
13042 (char *) "self",(char *) "x",(char *) "y", NULL
13043 };
13044
13045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_GetPixel",kwnames,&obj0,&obj1,&obj2)) goto fail;
13046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13047 if (SWIG_arg_fail(1)) SWIG_fail;
13048 {
13049 arg2 = (int)(SWIG_As_int(obj1));
13050 if (SWIG_arg_fail(2)) SWIG_fail;
13051 }
13052 {
13053 arg3 = (int)(SWIG_As_int(obj2));
13054 if (SWIG_arg_fail(3)) SWIG_fail;
13055 }
13056 {
13057 PyThreadState* __tstate = wxPyBeginAllowThreads();
13058 result = wxDC_GetPixel(arg1,arg2,arg3);
13059
13060 wxPyEndAllowThreads(__tstate);
13061 if (PyErr_Occurred()) SWIG_fail;
13062 }
13063 {
13064 wxColour * resultptr;
13065 resultptr = new wxColour((wxColour &)(result));
13066 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13067 }
13068 return resultobj;
13069 fail:
13070 return NULL;
13071 }
13072
13073
13074 static PyObject *_wrap_DC_GetPixelPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13075 PyObject *resultobj;
13076 wxDC *arg1 = (wxDC *) 0 ;
13077 wxPoint *arg2 = 0 ;
13078 wxColour result;
13079 wxPoint temp2 ;
13080 PyObject * obj0 = 0 ;
13081 PyObject * obj1 = 0 ;
13082 char *kwnames[] = {
13083 (char *) "self",(char *) "pt", NULL
13084 };
13085
13086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPixelPoint",kwnames,&obj0,&obj1)) goto fail;
13087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13088 if (SWIG_arg_fail(1)) SWIG_fail;
13089 {
13090 arg2 = &temp2;
13091 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13092 }
13093 {
13094 PyThreadState* __tstate = wxPyBeginAllowThreads();
13095 result = wxDC_GetPixelPoint(arg1,(wxPoint const &)*arg2);
13096
13097 wxPyEndAllowThreads(__tstate);
13098 if (PyErr_Occurred()) SWIG_fail;
13099 }
13100 {
13101 wxColour * resultptr;
13102 resultptr = new wxColour((wxColour &)(result));
13103 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13104 }
13105 return resultobj;
13106 fail:
13107 return NULL;
13108 }
13109
13110
13111 static PyObject *_wrap_DC_DrawLine(PyObject *, PyObject *args, PyObject *kwargs) {
13112 PyObject *resultobj;
13113 wxDC *arg1 = (wxDC *) 0 ;
13114 int arg2 ;
13115 int arg3 ;
13116 int arg4 ;
13117 int arg5 ;
13118 PyObject * obj0 = 0 ;
13119 PyObject * obj1 = 0 ;
13120 PyObject * obj2 = 0 ;
13121 PyObject * obj3 = 0 ;
13122 PyObject * obj4 = 0 ;
13123 char *kwnames[] = {
13124 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2", NULL
13125 };
13126
13127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13129 if (SWIG_arg_fail(1)) SWIG_fail;
13130 {
13131 arg2 = (int)(SWIG_As_int(obj1));
13132 if (SWIG_arg_fail(2)) SWIG_fail;
13133 }
13134 {
13135 arg3 = (int)(SWIG_As_int(obj2));
13136 if (SWIG_arg_fail(3)) SWIG_fail;
13137 }
13138 {
13139 arg4 = (int)(SWIG_As_int(obj3));
13140 if (SWIG_arg_fail(4)) SWIG_fail;
13141 }
13142 {
13143 arg5 = (int)(SWIG_As_int(obj4));
13144 if (SWIG_arg_fail(5)) SWIG_fail;
13145 }
13146 {
13147 PyThreadState* __tstate = wxPyBeginAllowThreads();
13148 (arg1)->DrawLine(arg2,arg3,arg4,arg5);
13149
13150 wxPyEndAllowThreads(__tstate);
13151 if (PyErr_Occurred()) SWIG_fail;
13152 }
13153 Py_INCREF(Py_None); resultobj = Py_None;
13154 return resultobj;
13155 fail:
13156 return NULL;
13157 }
13158
13159
13160 static PyObject *_wrap_DC_DrawLinePoint(PyObject *, PyObject *args, PyObject *kwargs) {
13161 PyObject *resultobj;
13162 wxDC *arg1 = (wxDC *) 0 ;
13163 wxPoint *arg2 = 0 ;
13164 wxPoint *arg3 = 0 ;
13165 wxPoint temp2 ;
13166 wxPoint temp3 ;
13167 PyObject * obj0 = 0 ;
13168 PyObject * obj1 = 0 ;
13169 PyObject * obj2 = 0 ;
13170 char *kwnames[] = {
13171 (char *) "self",(char *) "pt1",(char *) "pt2", NULL
13172 };
13173
13174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawLinePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13176 if (SWIG_arg_fail(1)) SWIG_fail;
13177 {
13178 arg2 = &temp2;
13179 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13180 }
13181 {
13182 arg3 = &temp3;
13183 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13184 }
13185 {
13186 PyThreadState* __tstate = wxPyBeginAllowThreads();
13187 (arg1)->DrawLine((wxPoint const &)*arg2,(wxPoint const &)*arg3);
13188
13189 wxPyEndAllowThreads(__tstate);
13190 if (PyErr_Occurred()) SWIG_fail;
13191 }
13192 Py_INCREF(Py_None); resultobj = Py_None;
13193 return resultobj;
13194 fail:
13195 return NULL;
13196 }
13197
13198
13199 static PyObject *_wrap_DC_CrossHair(PyObject *, PyObject *args, PyObject *kwargs) {
13200 PyObject *resultobj;
13201 wxDC *arg1 = (wxDC *) 0 ;
13202 int arg2 ;
13203 int arg3 ;
13204 PyObject * obj0 = 0 ;
13205 PyObject * obj1 = 0 ;
13206 PyObject * obj2 = 0 ;
13207 char *kwnames[] = {
13208 (char *) "self",(char *) "x",(char *) "y", NULL
13209 };
13210
13211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CrossHair",kwnames,&obj0,&obj1,&obj2)) goto fail;
13212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13213 if (SWIG_arg_fail(1)) SWIG_fail;
13214 {
13215 arg2 = (int)(SWIG_As_int(obj1));
13216 if (SWIG_arg_fail(2)) SWIG_fail;
13217 }
13218 {
13219 arg3 = (int)(SWIG_As_int(obj2));
13220 if (SWIG_arg_fail(3)) SWIG_fail;
13221 }
13222 {
13223 PyThreadState* __tstate = wxPyBeginAllowThreads();
13224 (arg1)->CrossHair(arg2,arg3);
13225
13226 wxPyEndAllowThreads(__tstate);
13227 if (PyErr_Occurred()) SWIG_fail;
13228 }
13229 Py_INCREF(Py_None); resultobj = Py_None;
13230 return resultobj;
13231 fail:
13232 return NULL;
13233 }
13234
13235
13236 static PyObject *_wrap_DC_CrossHairPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13237 PyObject *resultobj;
13238 wxDC *arg1 = (wxDC *) 0 ;
13239 wxPoint *arg2 = 0 ;
13240 wxPoint temp2 ;
13241 PyObject * obj0 = 0 ;
13242 PyObject * obj1 = 0 ;
13243 char *kwnames[] = {
13244 (char *) "self",(char *) "pt", NULL
13245 };
13246
13247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CrossHairPoint",kwnames,&obj0,&obj1)) goto fail;
13248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13249 if (SWIG_arg_fail(1)) SWIG_fail;
13250 {
13251 arg2 = &temp2;
13252 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13253 }
13254 {
13255 PyThreadState* __tstate = wxPyBeginAllowThreads();
13256 (arg1)->CrossHair((wxPoint const &)*arg2);
13257
13258 wxPyEndAllowThreads(__tstate);
13259 if (PyErr_Occurred()) SWIG_fail;
13260 }
13261 Py_INCREF(Py_None); resultobj = Py_None;
13262 return resultobj;
13263 fail:
13264 return NULL;
13265 }
13266
13267
13268 static PyObject *_wrap_DC_DrawArc(PyObject *, PyObject *args, PyObject *kwargs) {
13269 PyObject *resultobj;
13270 wxDC *arg1 = (wxDC *) 0 ;
13271 int arg2 ;
13272 int arg3 ;
13273 int arg4 ;
13274 int arg5 ;
13275 int arg6 ;
13276 int arg7 ;
13277 PyObject * obj0 = 0 ;
13278 PyObject * obj1 = 0 ;
13279 PyObject * obj2 = 0 ;
13280 PyObject * obj3 = 0 ;
13281 PyObject * obj4 = 0 ;
13282 PyObject * obj5 = 0 ;
13283 PyObject * obj6 = 0 ;
13284 char *kwnames[] = {
13285 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2",(char *) "xc",(char *) "yc", NULL
13286 };
13287
13288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13290 if (SWIG_arg_fail(1)) SWIG_fail;
13291 {
13292 arg2 = (int)(SWIG_As_int(obj1));
13293 if (SWIG_arg_fail(2)) SWIG_fail;
13294 }
13295 {
13296 arg3 = (int)(SWIG_As_int(obj2));
13297 if (SWIG_arg_fail(3)) SWIG_fail;
13298 }
13299 {
13300 arg4 = (int)(SWIG_As_int(obj3));
13301 if (SWIG_arg_fail(4)) SWIG_fail;
13302 }
13303 {
13304 arg5 = (int)(SWIG_As_int(obj4));
13305 if (SWIG_arg_fail(5)) SWIG_fail;
13306 }
13307 {
13308 arg6 = (int)(SWIG_As_int(obj5));
13309 if (SWIG_arg_fail(6)) SWIG_fail;
13310 }
13311 {
13312 arg7 = (int)(SWIG_As_int(obj6));
13313 if (SWIG_arg_fail(7)) SWIG_fail;
13314 }
13315 {
13316 PyThreadState* __tstate = wxPyBeginAllowThreads();
13317 (arg1)->DrawArc(arg2,arg3,arg4,arg5,arg6,arg7);
13318
13319 wxPyEndAllowThreads(__tstate);
13320 if (PyErr_Occurred()) SWIG_fail;
13321 }
13322 Py_INCREF(Py_None); resultobj = Py_None;
13323 return resultobj;
13324 fail:
13325 return NULL;
13326 }
13327
13328
13329 static PyObject *_wrap_DC_DrawArcPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13330 PyObject *resultobj;
13331 wxDC *arg1 = (wxDC *) 0 ;
13332 wxPoint *arg2 = 0 ;
13333 wxPoint *arg3 = 0 ;
13334 wxPoint *arg4 = 0 ;
13335 wxPoint temp2 ;
13336 wxPoint temp3 ;
13337 wxPoint temp4 ;
13338 PyObject * obj0 = 0 ;
13339 PyObject * obj1 = 0 ;
13340 PyObject * obj2 = 0 ;
13341 PyObject * obj3 = 0 ;
13342 char *kwnames[] = {
13343 (char *) "self",(char *) "pt1",(char *) "pt2",(char *) "center", NULL
13344 };
13345
13346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawArcPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13348 if (SWIG_arg_fail(1)) SWIG_fail;
13349 {
13350 arg2 = &temp2;
13351 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13352 }
13353 {
13354 arg3 = &temp3;
13355 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13356 }
13357 {
13358 arg4 = &temp4;
13359 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
13360 }
13361 {
13362 PyThreadState* __tstate = wxPyBeginAllowThreads();
13363 (arg1)->DrawArc((wxPoint const &)*arg2,(wxPoint const &)*arg3,(wxPoint const &)*arg4);
13364
13365 wxPyEndAllowThreads(__tstate);
13366 if (PyErr_Occurred()) SWIG_fail;
13367 }
13368 Py_INCREF(Py_None); resultobj = Py_None;
13369 return resultobj;
13370 fail:
13371 return NULL;
13372 }
13373
13374
13375 static PyObject *_wrap_DC_DrawCheckMark(PyObject *, PyObject *args, PyObject *kwargs) {
13376 PyObject *resultobj;
13377 wxDC *arg1 = (wxDC *) 0 ;
13378 int arg2 ;
13379 int arg3 ;
13380 int arg4 ;
13381 int arg5 ;
13382 PyObject * obj0 = 0 ;
13383 PyObject * obj1 = 0 ;
13384 PyObject * obj2 = 0 ;
13385 PyObject * obj3 = 0 ;
13386 PyObject * obj4 = 0 ;
13387 char *kwnames[] = {
13388 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13389 };
13390
13391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawCheckMark",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13393 if (SWIG_arg_fail(1)) SWIG_fail;
13394 {
13395 arg2 = (int)(SWIG_As_int(obj1));
13396 if (SWIG_arg_fail(2)) SWIG_fail;
13397 }
13398 {
13399 arg3 = (int)(SWIG_As_int(obj2));
13400 if (SWIG_arg_fail(3)) SWIG_fail;
13401 }
13402 {
13403 arg4 = (int)(SWIG_As_int(obj3));
13404 if (SWIG_arg_fail(4)) SWIG_fail;
13405 }
13406 {
13407 arg5 = (int)(SWIG_As_int(obj4));
13408 if (SWIG_arg_fail(5)) SWIG_fail;
13409 }
13410 {
13411 PyThreadState* __tstate = wxPyBeginAllowThreads();
13412 (arg1)->DrawCheckMark(arg2,arg3,arg4,arg5);
13413
13414 wxPyEndAllowThreads(__tstate);
13415 if (PyErr_Occurred()) SWIG_fail;
13416 }
13417 Py_INCREF(Py_None); resultobj = Py_None;
13418 return resultobj;
13419 fail:
13420 return NULL;
13421 }
13422
13423
13424 static PyObject *_wrap_DC_DrawCheckMarkRect(PyObject *, PyObject *args, PyObject *kwargs) {
13425 PyObject *resultobj;
13426 wxDC *arg1 = (wxDC *) 0 ;
13427 wxRect *arg2 = 0 ;
13428 wxRect temp2 ;
13429 PyObject * obj0 = 0 ;
13430 PyObject * obj1 = 0 ;
13431 char *kwnames[] = {
13432 (char *) "self",(char *) "rect", NULL
13433 };
13434
13435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawCheckMarkRect",kwnames,&obj0,&obj1)) goto fail;
13436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13437 if (SWIG_arg_fail(1)) SWIG_fail;
13438 {
13439 arg2 = &temp2;
13440 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13441 }
13442 {
13443 PyThreadState* __tstate = wxPyBeginAllowThreads();
13444 (arg1)->DrawCheckMark((wxRect const &)*arg2);
13445
13446 wxPyEndAllowThreads(__tstate);
13447 if (PyErr_Occurred()) SWIG_fail;
13448 }
13449 Py_INCREF(Py_None); resultobj = Py_None;
13450 return resultobj;
13451 fail:
13452 return NULL;
13453 }
13454
13455
13456 static PyObject *_wrap_DC_DrawEllipticArc(PyObject *, PyObject *args, PyObject *kwargs) {
13457 PyObject *resultobj;
13458 wxDC *arg1 = (wxDC *) 0 ;
13459 int arg2 ;
13460 int arg3 ;
13461 int arg4 ;
13462 int arg5 ;
13463 double arg6 ;
13464 double arg7 ;
13465 PyObject * obj0 = 0 ;
13466 PyObject * obj1 = 0 ;
13467 PyObject * obj2 = 0 ;
13468 PyObject * obj3 = 0 ;
13469 PyObject * obj4 = 0 ;
13470 PyObject * obj5 = 0 ;
13471 PyObject * obj6 = 0 ;
13472 char *kwnames[] = {
13473 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h",(char *) "start",(char *) "end", NULL
13474 };
13475
13476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawEllipticArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13478 if (SWIG_arg_fail(1)) SWIG_fail;
13479 {
13480 arg2 = (int)(SWIG_As_int(obj1));
13481 if (SWIG_arg_fail(2)) SWIG_fail;
13482 }
13483 {
13484 arg3 = (int)(SWIG_As_int(obj2));
13485 if (SWIG_arg_fail(3)) SWIG_fail;
13486 }
13487 {
13488 arg4 = (int)(SWIG_As_int(obj3));
13489 if (SWIG_arg_fail(4)) SWIG_fail;
13490 }
13491 {
13492 arg5 = (int)(SWIG_As_int(obj4));
13493 if (SWIG_arg_fail(5)) SWIG_fail;
13494 }
13495 {
13496 arg6 = (double)(SWIG_As_double(obj5));
13497 if (SWIG_arg_fail(6)) SWIG_fail;
13498 }
13499 {
13500 arg7 = (double)(SWIG_As_double(obj6));
13501 if (SWIG_arg_fail(7)) SWIG_fail;
13502 }
13503 {
13504 PyThreadState* __tstate = wxPyBeginAllowThreads();
13505 (arg1)->DrawEllipticArc(arg2,arg3,arg4,arg5,arg6,arg7);
13506
13507 wxPyEndAllowThreads(__tstate);
13508 if (PyErr_Occurred()) SWIG_fail;
13509 }
13510 Py_INCREF(Py_None); resultobj = Py_None;
13511 return resultobj;
13512 fail:
13513 return NULL;
13514 }
13515
13516
13517 static PyObject *_wrap_DC_DrawEllipticArcPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13518 PyObject *resultobj;
13519 wxDC *arg1 = (wxDC *) 0 ;
13520 wxPoint *arg2 = 0 ;
13521 wxSize *arg3 = 0 ;
13522 double arg4 ;
13523 double arg5 ;
13524 wxPoint temp2 ;
13525 wxSize temp3 ;
13526 PyObject * obj0 = 0 ;
13527 PyObject * obj1 = 0 ;
13528 PyObject * obj2 = 0 ;
13529 PyObject * obj3 = 0 ;
13530 PyObject * obj4 = 0 ;
13531 char *kwnames[] = {
13532 (char *) "self",(char *) "pt",(char *) "sz",(char *) "start",(char *) "end", NULL
13533 };
13534
13535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipticArcPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13537 if (SWIG_arg_fail(1)) SWIG_fail;
13538 {
13539 arg2 = &temp2;
13540 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13541 }
13542 {
13543 arg3 = &temp3;
13544 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13545 }
13546 {
13547 arg4 = (double)(SWIG_As_double(obj3));
13548 if (SWIG_arg_fail(4)) SWIG_fail;
13549 }
13550 {
13551 arg5 = (double)(SWIG_As_double(obj4));
13552 if (SWIG_arg_fail(5)) SWIG_fail;
13553 }
13554 {
13555 PyThreadState* __tstate = wxPyBeginAllowThreads();
13556 (arg1)->DrawEllipticArc((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,arg5);
13557
13558 wxPyEndAllowThreads(__tstate);
13559 if (PyErr_Occurred()) SWIG_fail;
13560 }
13561 Py_INCREF(Py_None); resultobj = Py_None;
13562 return resultobj;
13563 fail:
13564 return NULL;
13565 }
13566
13567
13568 static PyObject *_wrap_DC_DrawPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13569 PyObject *resultobj;
13570 wxDC *arg1 = (wxDC *) 0 ;
13571 int arg2 ;
13572 int arg3 ;
13573 PyObject * obj0 = 0 ;
13574 PyObject * obj1 = 0 ;
13575 PyObject * obj2 = 0 ;
13576 char *kwnames[] = {
13577 (char *) "self",(char *) "x",(char *) "y", NULL
13578 };
13579
13580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13582 if (SWIG_arg_fail(1)) SWIG_fail;
13583 {
13584 arg2 = (int)(SWIG_As_int(obj1));
13585 if (SWIG_arg_fail(2)) SWIG_fail;
13586 }
13587 {
13588 arg3 = (int)(SWIG_As_int(obj2));
13589 if (SWIG_arg_fail(3)) SWIG_fail;
13590 }
13591 {
13592 PyThreadState* __tstate = wxPyBeginAllowThreads();
13593 (arg1)->DrawPoint(arg2,arg3);
13594
13595 wxPyEndAllowThreads(__tstate);
13596 if (PyErr_Occurred()) SWIG_fail;
13597 }
13598 Py_INCREF(Py_None); resultobj = Py_None;
13599 return resultobj;
13600 fail:
13601 return NULL;
13602 }
13603
13604
13605 static PyObject *_wrap_DC_DrawPointPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13606 PyObject *resultobj;
13607 wxDC *arg1 = (wxDC *) 0 ;
13608 wxPoint *arg2 = 0 ;
13609 wxPoint temp2 ;
13610 PyObject * obj0 = 0 ;
13611 PyObject * obj1 = 0 ;
13612 char *kwnames[] = {
13613 (char *) "self",(char *) "pt", NULL
13614 };
13615
13616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawPointPoint",kwnames,&obj0,&obj1)) goto fail;
13617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13618 if (SWIG_arg_fail(1)) SWIG_fail;
13619 {
13620 arg2 = &temp2;
13621 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13622 }
13623 {
13624 PyThreadState* __tstate = wxPyBeginAllowThreads();
13625 (arg1)->DrawPoint((wxPoint const &)*arg2);
13626
13627 wxPyEndAllowThreads(__tstate);
13628 if (PyErr_Occurred()) SWIG_fail;
13629 }
13630 Py_INCREF(Py_None); resultobj = Py_None;
13631 return resultobj;
13632 fail:
13633 return NULL;
13634 }
13635
13636
13637 static PyObject *_wrap_DC_DrawRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13638 PyObject *resultobj;
13639 wxDC *arg1 = (wxDC *) 0 ;
13640 int arg2 ;
13641 int arg3 ;
13642 int arg4 ;
13643 int arg5 ;
13644 PyObject * obj0 = 0 ;
13645 PyObject * obj1 = 0 ;
13646 PyObject * obj2 = 0 ;
13647 PyObject * obj3 = 0 ;
13648 PyObject * obj4 = 0 ;
13649 char *kwnames[] = {
13650 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13651 };
13652
13653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13655 if (SWIG_arg_fail(1)) SWIG_fail;
13656 {
13657 arg2 = (int)(SWIG_As_int(obj1));
13658 if (SWIG_arg_fail(2)) SWIG_fail;
13659 }
13660 {
13661 arg3 = (int)(SWIG_As_int(obj2));
13662 if (SWIG_arg_fail(3)) SWIG_fail;
13663 }
13664 {
13665 arg4 = (int)(SWIG_As_int(obj3));
13666 if (SWIG_arg_fail(4)) SWIG_fail;
13667 }
13668 {
13669 arg5 = (int)(SWIG_As_int(obj4));
13670 if (SWIG_arg_fail(5)) SWIG_fail;
13671 }
13672 {
13673 PyThreadState* __tstate = wxPyBeginAllowThreads();
13674 (arg1)->DrawRectangle(arg2,arg3,arg4,arg5);
13675
13676 wxPyEndAllowThreads(__tstate);
13677 if (PyErr_Occurred()) SWIG_fail;
13678 }
13679 Py_INCREF(Py_None); resultobj = Py_None;
13680 return resultobj;
13681 fail:
13682 return NULL;
13683 }
13684
13685
13686 static PyObject *_wrap_DC_DrawRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13687 PyObject *resultobj;
13688 wxDC *arg1 = (wxDC *) 0 ;
13689 wxRect *arg2 = 0 ;
13690 wxRect temp2 ;
13691 PyObject * obj0 = 0 ;
13692 PyObject * obj1 = 0 ;
13693 char *kwnames[] = {
13694 (char *) "self",(char *) "rect", NULL
13695 };
13696
13697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawRectangleRect",kwnames,&obj0,&obj1)) goto fail;
13698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13699 if (SWIG_arg_fail(1)) SWIG_fail;
13700 {
13701 arg2 = &temp2;
13702 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13703 }
13704 {
13705 PyThreadState* __tstate = wxPyBeginAllowThreads();
13706 (arg1)->DrawRectangle((wxRect const &)*arg2);
13707
13708 wxPyEndAllowThreads(__tstate);
13709 if (PyErr_Occurred()) SWIG_fail;
13710 }
13711 Py_INCREF(Py_None); resultobj = Py_None;
13712 return resultobj;
13713 fail:
13714 return NULL;
13715 }
13716
13717
13718 static PyObject *_wrap_DC_DrawRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13719 PyObject *resultobj;
13720 wxDC *arg1 = (wxDC *) 0 ;
13721 wxPoint *arg2 = 0 ;
13722 wxSize *arg3 = 0 ;
13723 wxPoint temp2 ;
13724 wxSize temp3 ;
13725 PyObject * obj0 = 0 ;
13726 PyObject * obj1 = 0 ;
13727 PyObject * obj2 = 0 ;
13728 char *kwnames[] = {
13729 (char *) "self",(char *) "pt",(char *) "sz", NULL
13730 };
13731
13732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRectanglePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13734 if (SWIG_arg_fail(1)) SWIG_fail;
13735 {
13736 arg2 = &temp2;
13737 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13738 }
13739 {
13740 arg3 = &temp3;
13741 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13742 }
13743 {
13744 PyThreadState* __tstate = wxPyBeginAllowThreads();
13745 (arg1)->DrawRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3);
13746
13747 wxPyEndAllowThreads(__tstate);
13748 if (PyErr_Occurred()) SWIG_fail;
13749 }
13750 Py_INCREF(Py_None); resultobj = Py_None;
13751 return resultobj;
13752 fail:
13753 return NULL;
13754 }
13755
13756
13757 static PyObject *_wrap_DC_DrawRoundedRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13758 PyObject *resultobj;
13759 wxDC *arg1 = (wxDC *) 0 ;
13760 int arg2 ;
13761 int arg3 ;
13762 int arg4 ;
13763 int arg5 ;
13764 double arg6 ;
13765 PyObject * obj0 = 0 ;
13766 PyObject * obj1 = 0 ;
13767 PyObject * obj2 = 0 ;
13768 PyObject * obj3 = 0 ;
13769 PyObject * obj4 = 0 ;
13770 PyObject * obj5 = 0 ;
13771 char *kwnames[] = {
13772 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "radius", NULL
13773 };
13774
13775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:DC_DrawRoundedRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
13776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13777 if (SWIG_arg_fail(1)) SWIG_fail;
13778 {
13779 arg2 = (int)(SWIG_As_int(obj1));
13780 if (SWIG_arg_fail(2)) SWIG_fail;
13781 }
13782 {
13783 arg3 = (int)(SWIG_As_int(obj2));
13784 if (SWIG_arg_fail(3)) SWIG_fail;
13785 }
13786 {
13787 arg4 = (int)(SWIG_As_int(obj3));
13788 if (SWIG_arg_fail(4)) SWIG_fail;
13789 }
13790 {
13791 arg5 = (int)(SWIG_As_int(obj4));
13792 if (SWIG_arg_fail(5)) SWIG_fail;
13793 }
13794 {
13795 arg6 = (double)(SWIG_As_double(obj5));
13796 if (SWIG_arg_fail(6)) SWIG_fail;
13797 }
13798 {
13799 PyThreadState* __tstate = wxPyBeginAllowThreads();
13800 (arg1)->DrawRoundedRectangle(arg2,arg3,arg4,arg5,arg6);
13801
13802 wxPyEndAllowThreads(__tstate);
13803 if (PyErr_Occurred()) SWIG_fail;
13804 }
13805 Py_INCREF(Py_None); resultobj = Py_None;
13806 return resultobj;
13807 fail:
13808 return NULL;
13809 }
13810
13811
13812 static PyObject *_wrap_DC_DrawRoundedRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13813 PyObject *resultobj;
13814 wxDC *arg1 = (wxDC *) 0 ;
13815 wxRect *arg2 = 0 ;
13816 double arg3 ;
13817 wxRect temp2 ;
13818 PyObject * obj0 = 0 ;
13819 PyObject * obj1 = 0 ;
13820 PyObject * obj2 = 0 ;
13821 char *kwnames[] = {
13822 (char *) "self",(char *) "r",(char *) "radius", NULL
13823 };
13824
13825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRoundedRectangleRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
13826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13827 if (SWIG_arg_fail(1)) SWIG_fail;
13828 {
13829 arg2 = &temp2;
13830 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13831 }
13832 {
13833 arg3 = (double)(SWIG_As_double(obj2));
13834 if (SWIG_arg_fail(3)) SWIG_fail;
13835 }
13836 {
13837 PyThreadState* __tstate = wxPyBeginAllowThreads();
13838 (arg1)->DrawRoundedRectangle((wxRect const &)*arg2,arg3);
13839
13840 wxPyEndAllowThreads(__tstate);
13841 if (PyErr_Occurred()) SWIG_fail;
13842 }
13843 Py_INCREF(Py_None); resultobj = Py_None;
13844 return resultobj;
13845 fail:
13846 return NULL;
13847 }
13848
13849
13850 static PyObject *_wrap_DC_DrawRoundedRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13851 PyObject *resultobj;
13852 wxDC *arg1 = (wxDC *) 0 ;
13853 wxPoint *arg2 = 0 ;
13854 wxSize *arg3 = 0 ;
13855 double arg4 ;
13856 wxPoint temp2 ;
13857 wxSize temp3 ;
13858 PyObject * obj0 = 0 ;
13859 PyObject * obj1 = 0 ;
13860 PyObject * obj2 = 0 ;
13861 PyObject * obj3 = 0 ;
13862 char *kwnames[] = {
13863 (char *) "self",(char *) "pt",(char *) "sz",(char *) "radius", NULL
13864 };
13865
13866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRoundedRectanglePointSize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13868 if (SWIG_arg_fail(1)) SWIG_fail;
13869 {
13870 arg2 = &temp2;
13871 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13872 }
13873 {
13874 arg3 = &temp3;
13875 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13876 }
13877 {
13878 arg4 = (double)(SWIG_As_double(obj3));
13879 if (SWIG_arg_fail(4)) SWIG_fail;
13880 }
13881 {
13882 PyThreadState* __tstate = wxPyBeginAllowThreads();
13883 (arg1)->DrawRoundedRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4);
13884
13885 wxPyEndAllowThreads(__tstate);
13886 if (PyErr_Occurred()) SWIG_fail;
13887 }
13888 Py_INCREF(Py_None); resultobj = Py_None;
13889 return resultobj;
13890 fail:
13891 return NULL;
13892 }
13893
13894
13895 static PyObject *_wrap_DC_DrawCircle(PyObject *, PyObject *args, PyObject *kwargs) {
13896 PyObject *resultobj;
13897 wxDC *arg1 = (wxDC *) 0 ;
13898 int arg2 ;
13899 int arg3 ;
13900 int arg4 ;
13901 PyObject * obj0 = 0 ;
13902 PyObject * obj1 = 0 ;
13903 PyObject * obj2 = 0 ;
13904 PyObject * obj3 = 0 ;
13905 char *kwnames[] = {
13906 (char *) "self",(char *) "x",(char *) "y",(char *) "radius", NULL
13907 };
13908
13909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawCircle",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13911 if (SWIG_arg_fail(1)) SWIG_fail;
13912 {
13913 arg2 = (int)(SWIG_As_int(obj1));
13914 if (SWIG_arg_fail(2)) SWIG_fail;
13915 }
13916 {
13917 arg3 = (int)(SWIG_As_int(obj2));
13918 if (SWIG_arg_fail(3)) SWIG_fail;
13919 }
13920 {
13921 arg4 = (int)(SWIG_As_int(obj3));
13922 if (SWIG_arg_fail(4)) SWIG_fail;
13923 }
13924 {
13925 PyThreadState* __tstate = wxPyBeginAllowThreads();
13926 (arg1)->DrawCircle(arg2,arg3,arg4);
13927
13928 wxPyEndAllowThreads(__tstate);
13929 if (PyErr_Occurred()) SWIG_fail;
13930 }
13931 Py_INCREF(Py_None); resultobj = Py_None;
13932 return resultobj;
13933 fail:
13934 return NULL;
13935 }
13936
13937
13938 static PyObject *_wrap_DC_DrawCirclePoint(PyObject *, PyObject *args, PyObject *kwargs) {
13939 PyObject *resultobj;
13940 wxDC *arg1 = (wxDC *) 0 ;
13941 wxPoint *arg2 = 0 ;
13942 int arg3 ;
13943 wxPoint temp2 ;
13944 PyObject * obj0 = 0 ;
13945 PyObject * obj1 = 0 ;
13946 PyObject * obj2 = 0 ;
13947 char *kwnames[] = {
13948 (char *) "self",(char *) "pt",(char *) "radius", NULL
13949 };
13950
13951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawCirclePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13953 if (SWIG_arg_fail(1)) SWIG_fail;
13954 {
13955 arg2 = &temp2;
13956 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13957 }
13958 {
13959 arg3 = (int)(SWIG_As_int(obj2));
13960 if (SWIG_arg_fail(3)) SWIG_fail;
13961 }
13962 {
13963 PyThreadState* __tstate = wxPyBeginAllowThreads();
13964 (arg1)->DrawCircle((wxPoint const &)*arg2,arg3);
13965
13966 wxPyEndAllowThreads(__tstate);
13967 if (PyErr_Occurred()) SWIG_fail;
13968 }
13969 Py_INCREF(Py_None); resultobj = Py_None;
13970 return resultobj;
13971 fail:
13972 return NULL;
13973 }
13974
13975
13976 static PyObject *_wrap_DC_DrawEllipse(PyObject *, PyObject *args, PyObject *kwargs) {
13977 PyObject *resultobj;
13978 wxDC *arg1 = (wxDC *) 0 ;
13979 int arg2 ;
13980 int arg3 ;
13981 int arg4 ;
13982 int arg5 ;
13983 PyObject * obj0 = 0 ;
13984 PyObject * obj1 = 0 ;
13985 PyObject * obj2 = 0 ;
13986 PyObject * obj3 = 0 ;
13987 PyObject * obj4 = 0 ;
13988 char *kwnames[] = {
13989 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13990 };
13991
13992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipse",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13994 if (SWIG_arg_fail(1)) SWIG_fail;
13995 {
13996 arg2 = (int)(SWIG_As_int(obj1));
13997 if (SWIG_arg_fail(2)) SWIG_fail;
13998 }
13999 {
14000 arg3 = (int)(SWIG_As_int(obj2));
14001 if (SWIG_arg_fail(3)) SWIG_fail;
14002 }
14003 {
14004 arg4 = (int)(SWIG_As_int(obj3));
14005 if (SWIG_arg_fail(4)) SWIG_fail;
14006 }
14007 {
14008 arg5 = (int)(SWIG_As_int(obj4));
14009 if (SWIG_arg_fail(5)) SWIG_fail;
14010 }
14011 {
14012 PyThreadState* __tstate = wxPyBeginAllowThreads();
14013 (arg1)->DrawEllipse(arg2,arg3,arg4,arg5);
14014
14015 wxPyEndAllowThreads(__tstate);
14016 if (PyErr_Occurred()) SWIG_fail;
14017 }
14018 Py_INCREF(Py_None); resultobj = Py_None;
14019 return resultobj;
14020 fail:
14021 return NULL;
14022 }
14023
14024
14025 static PyObject *_wrap_DC_DrawEllipseRect(PyObject *, PyObject *args, PyObject *kwargs) {
14026 PyObject *resultobj;
14027 wxDC *arg1 = (wxDC *) 0 ;
14028 wxRect *arg2 = 0 ;
14029 wxRect temp2 ;
14030 PyObject * obj0 = 0 ;
14031 PyObject * obj1 = 0 ;
14032 char *kwnames[] = {
14033 (char *) "self",(char *) "rect", NULL
14034 };
14035
14036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawEllipseRect",kwnames,&obj0,&obj1)) goto fail;
14037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14038 if (SWIG_arg_fail(1)) SWIG_fail;
14039 {
14040 arg2 = &temp2;
14041 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14042 }
14043 {
14044 PyThreadState* __tstate = wxPyBeginAllowThreads();
14045 (arg1)->DrawEllipse((wxRect const &)*arg2);
14046
14047 wxPyEndAllowThreads(__tstate);
14048 if (PyErr_Occurred()) SWIG_fail;
14049 }
14050 Py_INCREF(Py_None); resultobj = Py_None;
14051 return resultobj;
14052 fail:
14053 return NULL;
14054 }
14055
14056
14057 static PyObject *_wrap_DC_DrawEllipsePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14058 PyObject *resultobj;
14059 wxDC *arg1 = (wxDC *) 0 ;
14060 wxPoint *arg2 = 0 ;
14061 wxSize *arg3 = 0 ;
14062 wxPoint temp2 ;
14063 wxSize temp3 ;
14064 PyObject * obj0 = 0 ;
14065 PyObject * obj1 = 0 ;
14066 PyObject * obj2 = 0 ;
14067 char *kwnames[] = {
14068 (char *) "self",(char *) "pt",(char *) "sz", NULL
14069 };
14070
14071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawEllipsePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14073 if (SWIG_arg_fail(1)) SWIG_fail;
14074 {
14075 arg2 = &temp2;
14076 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14077 }
14078 {
14079 arg3 = &temp3;
14080 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14081 }
14082 {
14083 PyThreadState* __tstate = wxPyBeginAllowThreads();
14084 (arg1)->DrawEllipse((wxPoint const &)*arg2,(wxSize const &)*arg3);
14085
14086 wxPyEndAllowThreads(__tstate);
14087 if (PyErr_Occurred()) SWIG_fail;
14088 }
14089 Py_INCREF(Py_None); resultobj = Py_None;
14090 return resultobj;
14091 fail:
14092 return NULL;
14093 }
14094
14095
14096 static PyObject *_wrap_DC_DrawIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14097 PyObject *resultobj;
14098 wxDC *arg1 = (wxDC *) 0 ;
14099 wxIcon *arg2 = 0 ;
14100 int arg3 ;
14101 int arg4 ;
14102 PyObject * obj0 = 0 ;
14103 PyObject * obj1 = 0 ;
14104 PyObject * obj2 = 0 ;
14105 PyObject * obj3 = 0 ;
14106 char *kwnames[] = {
14107 (char *) "self",(char *) "icon",(char *) "x",(char *) "y", NULL
14108 };
14109
14110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14112 if (SWIG_arg_fail(1)) SWIG_fail;
14113 {
14114 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
14115 if (SWIG_arg_fail(2)) SWIG_fail;
14116 if (arg2 == NULL) {
14117 SWIG_null_ref("wxIcon");
14118 }
14119 if (SWIG_arg_fail(2)) SWIG_fail;
14120 }
14121 {
14122 arg3 = (int)(SWIG_As_int(obj2));
14123 if (SWIG_arg_fail(3)) SWIG_fail;
14124 }
14125 {
14126 arg4 = (int)(SWIG_As_int(obj3));
14127 if (SWIG_arg_fail(4)) SWIG_fail;
14128 }
14129 {
14130 PyThreadState* __tstate = wxPyBeginAllowThreads();
14131 (arg1)->DrawIcon((wxIcon const &)*arg2,arg3,arg4);
14132
14133 wxPyEndAllowThreads(__tstate);
14134 if (PyErr_Occurred()) SWIG_fail;
14135 }
14136 Py_INCREF(Py_None); resultobj = Py_None;
14137 return resultobj;
14138 fail:
14139 return NULL;
14140 }
14141
14142
14143 static PyObject *_wrap_DC_DrawIconPoint(PyObject *, PyObject *args, PyObject *kwargs) {
14144 PyObject *resultobj;
14145 wxDC *arg1 = (wxDC *) 0 ;
14146 wxIcon *arg2 = 0 ;
14147 wxPoint *arg3 = 0 ;
14148 wxPoint temp3 ;
14149 PyObject * obj0 = 0 ;
14150 PyObject * obj1 = 0 ;
14151 PyObject * obj2 = 0 ;
14152 char *kwnames[] = {
14153 (char *) "self",(char *) "icon",(char *) "pt", NULL
14154 };
14155
14156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawIconPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
14157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14158 if (SWIG_arg_fail(1)) SWIG_fail;
14159 {
14160 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
14161 if (SWIG_arg_fail(2)) SWIG_fail;
14162 if (arg2 == NULL) {
14163 SWIG_null_ref("wxIcon");
14164 }
14165 if (SWIG_arg_fail(2)) SWIG_fail;
14166 }
14167 {
14168 arg3 = &temp3;
14169 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14170 }
14171 {
14172 PyThreadState* __tstate = wxPyBeginAllowThreads();
14173 (arg1)->DrawIcon((wxIcon const &)*arg2,(wxPoint const &)*arg3);
14174
14175 wxPyEndAllowThreads(__tstate);
14176 if (PyErr_Occurred()) SWIG_fail;
14177 }
14178 Py_INCREF(Py_None); resultobj = Py_None;
14179 return resultobj;
14180 fail:
14181 return NULL;
14182 }
14183
14184
14185 static PyObject *_wrap_DC_DrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14186 PyObject *resultobj;
14187 wxDC *arg1 = (wxDC *) 0 ;
14188 wxBitmap *arg2 = 0 ;
14189 int arg3 ;
14190 int arg4 ;
14191 bool arg5 = (bool) false ;
14192 PyObject * obj0 = 0 ;
14193 PyObject * obj1 = 0 ;
14194 PyObject * obj2 = 0 ;
14195 PyObject * obj3 = 0 ;
14196 PyObject * obj4 = 0 ;
14197 char *kwnames[] = {
14198 (char *) "self",(char *) "bmp",(char *) "x",(char *) "y",(char *) "useMask", NULL
14199 };
14200
14201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_DrawBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14203 if (SWIG_arg_fail(1)) SWIG_fail;
14204 {
14205 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
14206 if (SWIG_arg_fail(2)) SWIG_fail;
14207 if (arg2 == NULL) {
14208 SWIG_null_ref("wxBitmap");
14209 }
14210 if (SWIG_arg_fail(2)) SWIG_fail;
14211 }
14212 {
14213 arg3 = (int)(SWIG_As_int(obj2));
14214 if (SWIG_arg_fail(3)) SWIG_fail;
14215 }
14216 {
14217 arg4 = (int)(SWIG_As_int(obj3));
14218 if (SWIG_arg_fail(4)) SWIG_fail;
14219 }
14220 if (obj4) {
14221 {
14222 arg5 = (bool)(SWIG_As_bool(obj4));
14223 if (SWIG_arg_fail(5)) SWIG_fail;
14224 }
14225 }
14226 {
14227 PyThreadState* __tstate = wxPyBeginAllowThreads();
14228 (arg1)->DrawBitmap((wxBitmap const &)*arg2,arg3,arg4,arg5);
14229
14230 wxPyEndAllowThreads(__tstate);
14231 if (PyErr_Occurred()) SWIG_fail;
14232 }
14233 Py_INCREF(Py_None); resultobj = Py_None;
14234 return resultobj;
14235 fail:
14236 return NULL;
14237 }
14238
14239
14240 static PyObject *_wrap_DC_DrawBitmapPoint(PyObject *, PyObject *args, PyObject *kwargs) {
14241 PyObject *resultobj;
14242 wxDC *arg1 = (wxDC *) 0 ;
14243 wxBitmap *arg2 = 0 ;
14244 wxPoint *arg3 = 0 ;
14245 bool arg4 = (bool) false ;
14246 wxPoint temp3 ;
14247 PyObject * obj0 = 0 ;
14248 PyObject * obj1 = 0 ;
14249 PyObject * obj2 = 0 ;
14250 PyObject * obj3 = 0 ;
14251 char *kwnames[] = {
14252 (char *) "self",(char *) "bmp",(char *) "pt",(char *) "useMask", NULL
14253 };
14254
14255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_DrawBitmapPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14257 if (SWIG_arg_fail(1)) SWIG_fail;
14258 {
14259 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
14260 if (SWIG_arg_fail(2)) SWIG_fail;
14261 if (arg2 == NULL) {
14262 SWIG_null_ref("wxBitmap");
14263 }
14264 if (SWIG_arg_fail(2)) SWIG_fail;
14265 }
14266 {
14267 arg3 = &temp3;
14268 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14269 }
14270 if (obj3) {
14271 {
14272 arg4 = (bool)(SWIG_As_bool(obj3));
14273 if (SWIG_arg_fail(4)) SWIG_fail;
14274 }
14275 }
14276 {
14277 PyThreadState* __tstate = wxPyBeginAllowThreads();
14278 (arg1)->DrawBitmap((wxBitmap const &)*arg2,(wxPoint const &)*arg3,arg4);
14279
14280 wxPyEndAllowThreads(__tstate);
14281 if (PyErr_Occurred()) SWIG_fail;
14282 }
14283 Py_INCREF(Py_None); resultobj = Py_None;
14284 return resultobj;
14285 fail:
14286 return NULL;
14287 }
14288
14289
14290 static PyObject *_wrap_DC_DrawText(PyObject *, PyObject *args, PyObject *kwargs) {
14291 PyObject *resultobj;
14292 wxDC *arg1 = (wxDC *) 0 ;
14293 wxString *arg2 = 0 ;
14294 int arg3 ;
14295 int arg4 ;
14296 bool temp2 = false ;
14297 PyObject * obj0 = 0 ;
14298 PyObject * obj1 = 0 ;
14299 PyObject * obj2 = 0 ;
14300 PyObject * obj3 = 0 ;
14301 char *kwnames[] = {
14302 (char *) "self",(char *) "text",(char *) "x",(char *) "y", NULL
14303 };
14304
14305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawText",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14307 if (SWIG_arg_fail(1)) SWIG_fail;
14308 {
14309 arg2 = wxString_in_helper(obj1);
14310 if (arg2 == NULL) SWIG_fail;
14311 temp2 = true;
14312 }
14313 {
14314 arg3 = (int)(SWIG_As_int(obj2));
14315 if (SWIG_arg_fail(3)) SWIG_fail;
14316 }
14317 {
14318 arg4 = (int)(SWIG_As_int(obj3));
14319 if (SWIG_arg_fail(4)) SWIG_fail;
14320 }
14321 {
14322 PyThreadState* __tstate = wxPyBeginAllowThreads();
14323 (arg1)->DrawText((wxString const &)*arg2,arg3,arg4);
14324
14325 wxPyEndAllowThreads(__tstate);
14326 if (PyErr_Occurred()) SWIG_fail;
14327 }
14328 Py_INCREF(Py_None); resultobj = Py_None;
14329 {
14330 if (temp2)
14331 delete arg2;
14332 }
14333 return resultobj;
14334 fail:
14335 {
14336 if (temp2)
14337 delete arg2;
14338 }
14339 return NULL;
14340 }
14341
14342
14343 static PyObject *_wrap_DC_DrawTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
14344 PyObject *resultobj;
14345 wxDC *arg1 = (wxDC *) 0 ;
14346 wxString *arg2 = 0 ;
14347 wxPoint *arg3 = 0 ;
14348 bool temp2 = false ;
14349 wxPoint temp3 ;
14350 PyObject * obj0 = 0 ;
14351 PyObject * obj1 = 0 ;
14352 PyObject * obj2 = 0 ;
14353 char *kwnames[] = {
14354 (char *) "self",(char *) "text",(char *) "pt", NULL
14355 };
14356
14357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawTextPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
14358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14359 if (SWIG_arg_fail(1)) SWIG_fail;
14360 {
14361 arg2 = wxString_in_helper(obj1);
14362 if (arg2 == NULL) SWIG_fail;
14363 temp2 = true;
14364 }
14365 {
14366 arg3 = &temp3;
14367 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14368 }
14369 {
14370 PyThreadState* __tstate = wxPyBeginAllowThreads();
14371 (arg1)->DrawText((wxString const &)*arg2,(wxPoint const &)*arg3);
14372
14373 wxPyEndAllowThreads(__tstate);
14374 if (PyErr_Occurred()) SWIG_fail;
14375 }
14376 Py_INCREF(Py_None); resultobj = Py_None;
14377 {
14378 if (temp2)
14379 delete arg2;
14380 }
14381 return resultobj;
14382 fail:
14383 {
14384 if (temp2)
14385 delete arg2;
14386 }
14387 return NULL;
14388 }
14389
14390
14391 static PyObject *_wrap_DC_DrawRotatedText(PyObject *, PyObject *args, PyObject *kwargs) {
14392 PyObject *resultobj;
14393 wxDC *arg1 = (wxDC *) 0 ;
14394 wxString *arg2 = 0 ;
14395 int arg3 ;
14396 int arg4 ;
14397 double arg5 ;
14398 bool temp2 = false ;
14399 PyObject * obj0 = 0 ;
14400 PyObject * obj1 = 0 ;
14401 PyObject * obj2 = 0 ;
14402 PyObject * obj3 = 0 ;
14403 PyObject * obj4 = 0 ;
14404 char *kwnames[] = {
14405 (char *) "self",(char *) "text",(char *) "x",(char *) "y",(char *) "angle", NULL
14406 };
14407
14408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRotatedText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14410 if (SWIG_arg_fail(1)) SWIG_fail;
14411 {
14412 arg2 = wxString_in_helper(obj1);
14413 if (arg2 == NULL) SWIG_fail;
14414 temp2 = true;
14415 }
14416 {
14417 arg3 = (int)(SWIG_As_int(obj2));
14418 if (SWIG_arg_fail(3)) SWIG_fail;
14419 }
14420 {
14421 arg4 = (int)(SWIG_As_int(obj3));
14422 if (SWIG_arg_fail(4)) SWIG_fail;
14423 }
14424 {
14425 arg5 = (double)(SWIG_As_double(obj4));
14426 if (SWIG_arg_fail(5)) SWIG_fail;
14427 }
14428 {
14429 PyThreadState* __tstate = wxPyBeginAllowThreads();
14430 (arg1)->DrawRotatedText((wxString const &)*arg2,arg3,arg4,arg5);
14431
14432 wxPyEndAllowThreads(__tstate);
14433 if (PyErr_Occurred()) SWIG_fail;
14434 }
14435 Py_INCREF(Py_None); resultobj = Py_None;
14436 {
14437 if (temp2)
14438 delete arg2;
14439 }
14440 return resultobj;
14441 fail:
14442 {
14443 if (temp2)
14444 delete arg2;
14445 }
14446 return NULL;
14447 }
14448
14449
14450 static PyObject *_wrap_DC_DrawRotatedTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
14451 PyObject *resultobj;
14452 wxDC *arg1 = (wxDC *) 0 ;
14453 wxString *arg2 = 0 ;
14454 wxPoint *arg3 = 0 ;
14455 double arg4 ;
14456 bool temp2 = false ;
14457 wxPoint temp3 ;
14458 PyObject * obj0 = 0 ;
14459 PyObject * obj1 = 0 ;
14460 PyObject * obj2 = 0 ;
14461 PyObject * obj3 = 0 ;
14462 char *kwnames[] = {
14463 (char *) "self",(char *) "text",(char *) "pt",(char *) "angle", NULL
14464 };
14465
14466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRotatedTextPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14468 if (SWIG_arg_fail(1)) SWIG_fail;
14469 {
14470 arg2 = wxString_in_helper(obj1);
14471 if (arg2 == NULL) SWIG_fail;
14472 temp2 = true;
14473 }
14474 {
14475 arg3 = &temp3;
14476 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14477 }
14478 {
14479 arg4 = (double)(SWIG_As_double(obj3));
14480 if (SWIG_arg_fail(4)) SWIG_fail;
14481 }
14482 {
14483 PyThreadState* __tstate = wxPyBeginAllowThreads();
14484 (arg1)->DrawRotatedText((wxString const &)*arg2,(wxPoint const &)*arg3,arg4);
14485
14486 wxPyEndAllowThreads(__tstate);
14487 if (PyErr_Occurred()) SWIG_fail;
14488 }
14489 Py_INCREF(Py_None); resultobj = Py_None;
14490 {
14491 if (temp2)
14492 delete arg2;
14493 }
14494 return resultobj;
14495 fail:
14496 {
14497 if (temp2)
14498 delete arg2;
14499 }
14500 return NULL;
14501 }
14502
14503
14504 static PyObject *_wrap_DC_Blit(PyObject *, PyObject *args, PyObject *kwargs) {
14505 PyObject *resultobj;
14506 wxDC *arg1 = (wxDC *) 0 ;
14507 int arg2 ;
14508 int arg3 ;
14509 int arg4 ;
14510 int arg5 ;
14511 wxDC *arg6 = (wxDC *) 0 ;
14512 int arg7 ;
14513 int arg8 ;
14514 int arg9 = (int) wxCOPY ;
14515 bool arg10 = (bool) false ;
14516 int arg11 = (int) -1 ;
14517 int arg12 = (int) -1 ;
14518 bool result;
14519 PyObject * obj0 = 0 ;
14520 PyObject * obj1 = 0 ;
14521 PyObject * obj2 = 0 ;
14522 PyObject * obj3 = 0 ;
14523 PyObject * obj4 = 0 ;
14524 PyObject * obj5 = 0 ;
14525 PyObject * obj6 = 0 ;
14526 PyObject * obj7 = 0 ;
14527 PyObject * obj8 = 0 ;
14528 PyObject * obj9 = 0 ;
14529 PyObject * obj10 = 0 ;
14530 PyObject * obj11 = 0 ;
14531 char *kwnames[] = {
14532 (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
14533 };
14534
14535 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;
14536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14537 if (SWIG_arg_fail(1)) SWIG_fail;
14538 {
14539 arg2 = (int)(SWIG_As_int(obj1));
14540 if (SWIG_arg_fail(2)) SWIG_fail;
14541 }
14542 {
14543 arg3 = (int)(SWIG_As_int(obj2));
14544 if (SWIG_arg_fail(3)) SWIG_fail;
14545 }
14546 {
14547 arg4 = (int)(SWIG_As_int(obj3));
14548 if (SWIG_arg_fail(4)) SWIG_fail;
14549 }
14550 {
14551 arg5 = (int)(SWIG_As_int(obj4));
14552 if (SWIG_arg_fail(5)) SWIG_fail;
14553 }
14554 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14555 if (SWIG_arg_fail(6)) SWIG_fail;
14556 {
14557 arg7 = (int)(SWIG_As_int(obj6));
14558 if (SWIG_arg_fail(7)) SWIG_fail;
14559 }
14560 {
14561 arg8 = (int)(SWIG_As_int(obj7));
14562 if (SWIG_arg_fail(8)) SWIG_fail;
14563 }
14564 if (obj8) {
14565 {
14566 arg9 = (int)(SWIG_As_int(obj8));
14567 if (SWIG_arg_fail(9)) SWIG_fail;
14568 }
14569 }
14570 if (obj9) {
14571 {
14572 arg10 = (bool)(SWIG_As_bool(obj9));
14573 if (SWIG_arg_fail(10)) SWIG_fail;
14574 }
14575 }
14576 if (obj10) {
14577 {
14578 arg11 = (int)(SWIG_As_int(obj10));
14579 if (SWIG_arg_fail(11)) SWIG_fail;
14580 }
14581 }
14582 if (obj11) {
14583 {
14584 arg12 = (int)(SWIG_As_int(obj11));
14585 if (SWIG_arg_fail(12)) SWIG_fail;
14586 }
14587 }
14588 {
14589 PyThreadState* __tstate = wxPyBeginAllowThreads();
14590 result = (bool)(arg1)->Blit(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
14591
14592 wxPyEndAllowThreads(__tstate);
14593 if (PyErr_Occurred()) SWIG_fail;
14594 }
14595 {
14596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14597 }
14598 return resultobj;
14599 fail:
14600 return NULL;
14601 }
14602
14603
14604 static PyObject *_wrap_DC_BlitPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14605 PyObject *resultobj;
14606 wxDC *arg1 = (wxDC *) 0 ;
14607 wxPoint *arg2 = 0 ;
14608 wxSize *arg3 = 0 ;
14609 wxDC *arg4 = (wxDC *) 0 ;
14610 wxPoint *arg5 = 0 ;
14611 int arg6 = (int) wxCOPY ;
14612 bool arg7 = (bool) false ;
14613 wxPoint const &arg8_defvalue = wxDefaultPosition ;
14614 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
14615 bool result;
14616 wxPoint temp2 ;
14617 wxSize temp3 ;
14618 wxPoint temp5 ;
14619 wxPoint temp8 ;
14620 PyObject * obj0 = 0 ;
14621 PyObject * obj1 = 0 ;
14622 PyObject * obj2 = 0 ;
14623 PyObject * obj3 = 0 ;
14624 PyObject * obj4 = 0 ;
14625 PyObject * obj5 = 0 ;
14626 PyObject * obj6 = 0 ;
14627 PyObject * obj7 = 0 ;
14628 char *kwnames[] = {
14629 (char *) "self",(char *) "destPt",(char *) "sz",(char *) "source",(char *) "srcPt",(char *) "rop",(char *) "useMask",(char *) "srcPtMask", NULL
14630 };
14631
14632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:DC_BlitPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
14633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14634 if (SWIG_arg_fail(1)) SWIG_fail;
14635 {
14636 arg2 = &temp2;
14637 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14638 }
14639 {
14640 arg3 = &temp3;
14641 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14642 }
14643 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14644 if (SWIG_arg_fail(4)) SWIG_fail;
14645 {
14646 arg5 = &temp5;
14647 if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
14648 }
14649 if (obj5) {
14650 {
14651 arg6 = (int)(SWIG_As_int(obj5));
14652 if (SWIG_arg_fail(6)) SWIG_fail;
14653 }
14654 }
14655 if (obj6) {
14656 {
14657 arg7 = (bool)(SWIG_As_bool(obj6));
14658 if (SWIG_arg_fail(7)) SWIG_fail;
14659 }
14660 }
14661 if (obj7) {
14662 {
14663 arg8 = &temp8;
14664 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
14665 }
14666 }
14667 {
14668 PyThreadState* __tstate = wxPyBeginAllowThreads();
14669 result = (bool)(arg1)->Blit((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,(wxPoint const &)*arg5,arg6,arg7,(wxPoint const &)*arg8);
14670
14671 wxPyEndAllowThreads(__tstate);
14672 if (PyErr_Occurred()) SWIG_fail;
14673 }
14674 {
14675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14676 }
14677 return resultobj;
14678 fail:
14679 return NULL;
14680 }
14681
14682
14683 static PyObject *_wrap_DC_SetClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14684 PyObject *resultobj;
14685 wxDC *arg1 = (wxDC *) 0 ;
14686 int arg2 ;
14687 int arg3 ;
14688 int arg4 ;
14689 int arg5 ;
14690 PyObject * obj0 = 0 ;
14691 PyObject * obj1 = 0 ;
14692 PyObject * obj2 = 0 ;
14693 PyObject * obj3 = 0 ;
14694 PyObject * obj4 = 0 ;
14695 char *kwnames[] = {
14696 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
14697 };
14698
14699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_SetClippingRegion",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14701 if (SWIG_arg_fail(1)) SWIG_fail;
14702 {
14703 arg2 = (int)(SWIG_As_int(obj1));
14704 if (SWIG_arg_fail(2)) SWIG_fail;
14705 }
14706 {
14707 arg3 = (int)(SWIG_As_int(obj2));
14708 if (SWIG_arg_fail(3)) SWIG_fail;
14709 }
14710 {
14711 arg4 = (int)(SWIG_As_int(obj3));
14712 if (SWIG_arg_fail(4)) SWIG_fail;
14713 }
14714 {
14715 arg5 = (int)(SWIG_As_int(obj4));
14716 if (SWIG_arg_fail(5)) SWIG_fail;
14717 }
14718 {
14719 PyThreadState* __tstate = wxPyBeginAllowThreads();
14720 (arg1)->SetClippingRegion(arg2,arg3,arg4,arg5);
14721
14722 wxPyEndAllowThreads(__tstate);
14723 if (PyErr_Occurred()) SWIG_fail;
14724 }
14725 Py_INCREF(Py_None); resultobj = Py_None;
14726 return resultobj;
14727 fail:
14728 return NULL;
14729 }
14730
14731
14732 static PyObject *_wrap_DC_SetClippingRegionPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14733 PyObject *resultobj;
14734 wxDC *arg1 = (wxDC *) 0 ;
14735 wxPoint *arg2 = 0 ;
14736 wxSize *arg3 = 0 ;
14737 wxPoint temp2 ;
14738 wxSize temp3 ;
14739 PyObject * obj0 = 0 ;
14740 PyObject * obj1 = 0 ;
14741 PyObject * obj2 = 0 ;
14742 char *kwnames[] = {
14743 (char *) "self",(char *) "pt",(char *) "sz", NULL
14744 };
14745
14746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetClippingRegionPointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14748 if (SWIG_arg_fail(1)) SWIG_fail;
14749 {
14750 arg2 = &temp2;
14751 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14752 }
14753 {
14754 arg3 = &temp3;
14755 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14756 }
14757 {
14758 PyThreadState* __tstate = wxPyBeginAllowThreads();
14759 (arg1)->SetClippingRegion((wxPoint const &)*arg2,(wxSize const &)*arg3);
14760
14761 wxPyEndAllowThreads(__tstate);
14762 if (PyErr_Occurred()) SWIG_fail;
14763 }
14764 Py_INCREF(Py_None); resultobj = Py_None;
14765 return resultobj;
14766 fail:
14767 return NULL;
14768 }
14769
14770
14771 static PyObject *_wrap_DC_SetClippingRegionAsRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14772 PyObject *resultobj;
14773 wxDC *arg1 = (wxDC *) 0 ;
14774 wxRegion *arg2 = 0 ;
14775 PyObject * obj0 = 0 ;
14776 PyObject * obj1 = 0 ;
14777 char *kwnames[] = {
14778 (char *) "self",(char *) "region", NULL
14779 };
14780
14781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRegionAsRegion",kwnames,&obj0,&obj1)) goto fail;
14782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14783 if (SWIG_arg_fail(1)) SWIG_fail;
14784 {
14785 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
14786 if (SWIG_arg_fail(2)) SWIG_fail;
14787 if (arg2 == NULL) {
14788 SWIG_null_ref("wxRegion");
14789 }
14790 if (SWIG_arg_fail(2)) SWIG_fail;
14791 }
14792 {
14793 PyThreadState* __tstate = wxPyBeginAllowThreads();
14794 (arg1)->SetClippingRegion((wxRegion const &)*arg2);
14795
14796 wxPyEndAllowThreads(__tstate);
14797 if (PyErr_Occurred()) SWIG_fail;
14798 }
14799 Py_INCREF(Py_None); resultobj = Py_None;
14800 return resultobj;
14801 fail:
14802 return NULL;
14803 }
14804
14805
14806 static PyObject *_wrap_DC_SetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
14807 PyObject *resultobj;
14808 wxDC *arg1 = (wxDC *) 0 ;
14809 wxRect *arg2 = 0 ;
14810 wxRect temp2 ;
14811 PyObject * obj0 = 0 ;
14812 PyObject * obj1 = 0 ;
14813 char *kwnames[] = {
14814 (char *) "self",(char *) "rect", NULL
14815 };
14816
14817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRect",kwnames,&obj0,&obj1)) goto fail;
14818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14819 if (SWIG_arg_fail(1)) SWIG_fail;
14820 {
14821 arg2 = &temp2;
14822 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14823 }
14824 {
14825 PyThreadState* __tstate = wxPyBeginAllowThreads();
14826 (arg1)->SetClippingRegion((wxRect const &)*arg2);
14827
14828 wxPyEndAllowThreads(__tstate);
14829 if (PyErr_Occurred()) SWIG_fail;
14830 }
14831 Py_INCREF(Py_None); resultobj = Py_None;
14832 return resultobj;
14833 fail:
14834 return NULL;
14835 }
14836
14837
14838 static PyObject *_wrap_DC_DrawLines(PyObject *, PyObject *args, PyObject *kwargs) {
14839 PyObject *resultobj;
14840 wxDC *arg1 = (wxDC *) 0 ;
14841 int arg2 ;
14842 wxPoint *arg3 = (wxPoint *) 0 ;
14843 int arg4 = (int) 0 ;
14844 int arg5 = (int) 0 ;
14845 PyObject * obj0 = 0 ;
14846 PyObject * obj1 = 0 ;
14847 PyObject * obj2 = 0 ;
14848 PyObject * obj3 = 0 ;
14849 char *kwnames[] = {
14850 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset", NULL
14851 };
14852
14853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DC_DrawLines",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14855 if (SWIG_arg_fail(1)) SWIG_fail;
14856 {
14857 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14858 if (arg3 == NULL) SWIG_fail;
14859 }
14860 if (obj2) {
14861 {
14862 arg4 = (int)(SWIG_As_int(obj2));
14863 if (SWIG_arg_fail(4)) SWIG_fail;
14864 }
14865 }
14866 if (obj3) {
14867 {
14868 arg5 = (int)(SWIG_As_int(obj3));
14869 if (SWIG_arg_fail(5)) SWIG_fail;
14870 }
14871 }
14872 {
14873 PyThreadState* __tstate = wxPyBeginAllowThreads();
14874 (arg1)->DrawLines(arg2,arg3,arg4,arg5);
14875
14876 wxPyEndAllowThreads(__tstate);
14877 if (PyErr_Occurred()) SWIG_fail;
14878 }
14879 Py_INCREF(Py_None); resultobj = Py_None;
14880 {
14881 if (arg3) delete [] arg3;
14882 }
14883 return resultobj;
14884 fail:
14885 {
14886 if (arg3) delete [] arg3;
14887 }
14888 return NULL;
14889 }
14890
14891
14892 static PyObject *_wrap_DC_DrawPolygon(PyObject *, PyObject *args, PyObject *kwargs) {
14893 PyObject *resultobj;
14894 wxDC *arg1 = (wxDC *) 0 ;
14895 int arg2 ;
14896 wxPoint *arg3 = (wxPoint *) 0 ;
14897 int arg4 = (int) 0 ;
14898 int arg5 = (int) 0 ;
14899 int arg6 = (int) wxODDEVEN_RULE ;
14900 PyObject * obj0 = 0 ;
14901 PyObject * obj1 = 0 ;
14902 PyObject * obj2 = 0 ;
14903 PyObject * obj3 = 0 ;
14904 PyObject * obj4 = 0 ;
14905 char *kwnames[] = {
14906 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset",(char *) "fillStyle", NULL
14907 };
14908
14909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DC_DrawPolygon",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14911 if (SWIG_arg_fail(1)) SWIG_fail;
14912 {
14913 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14914 if (arg3 == NULL) SWIG_fail;
14915 }
14916 if (obj2) {
14917 {
14918 arg4 = (int)(SWIG_As_int(obj2));
14919 if (SWIG_arg_fail(4)) SWIG_fail;
14920 }
14921 }
14922 if (obj3) {
14923 {
14924 arg5 = (int)(SWIG_As_int(obj3));
14925 if (SWIG_arg_fail(5)) SWIG_fail;
14926 }
14927 }
14928 if (obj4) {
14929 {
14930 arg6 = (int)(SWIG_As_int(obj4));
14931 if (SWIG_arg_fail(6)) SWIG_fail;
14932 }
14933 }
14934 {
14935 PyThreadState* __tstate = wxPyBeginAllowThreads();
14936 (arg1)->DrawPolygon(arg2,arg3,arg4,arg5,arg6);
14937
14938 wxPyEndAllowThreads(__tstate);
14939 if (PyErr_Occurred()) SWIG_fail;
14940 }
14941 Py_INCREF(Py_None); resultobj = Py_None;
14942 {
14943 if (arg3) delete [] arg3;
14944 }
14945 return resultobj;
14946 fail:
14947 {
14948 if (arg3) delete [] arg3;
14949 }
14950 return NULL;
14951 }
14952
14953
14954 static PyObject *_wrap_DC_DrawLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14955 PyObject *resultobj;
14956 wxDC *arg1 = (wxDC *) 0 ;
14957 wxString *arg2 = 0 ;
14958 wxRect *arg3 = 0 ;
14959 int arg4 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14960 int arg5 = (int) -1 ;
14961 bool temp2 = false ;
14962 wxRect temp3 ;
14963 PyObject * obj0 = 0 ;
14964 PyObject * obj1 = 0 ;
14965 PyObject * obj2 = 0 ;
14966 PyObject * obj3 = 0 ;
14967 PyObject * obj4 = 0 ;
14968 char *kwnames[] = {
14969 (char *) "self",(char *) "text",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
14970 };
14971
14972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:DC_DrawLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14974 if (SWIG_arg_fail(1)) SWIG_fail;
14975 {
14976 arg2 = wxString_in_helper(obj1);
14977 if (arg2 == NULL) SWIG_fail;
14978 temp2 = true;
14979 }
14980 {
14981 arg3 = &temp3;
14982 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
14983 }
14984 if (obj3) {
14985 {
14986 arg4 = (int)(SWIG_As_int(obj3));
14987 if (SWIG_arg_fail(4)) SWIG_fail;
14988 }
14989 }
14990 if (obj4) {
14991 {
14992 arg5 = (int)(SWIG_As_int(obj4));
14993 if (SWIG_arg_fail(5)) SWIG_fail;
14994 }
14995 }
14996 {
14997 PyThreadState* __tstate = wxPyBeginAllowThreads();
14998 (arg1)->DrawLabel((wxString const &)*arg2,(wxRect const &)*arg3,arg4,arg5);
14999
15000 wxPyEndAllowThreads(__tstate);
15001 if (PyErr_Occurred()) SWIG_fail;
15002 }
15003 Py_INCREF(Py_None); resultobj = Py_None;
15004 {
15005 if (temp2)
15006 delete arg2;
15007 }
15008 return resultobj;
15009 fail:
15010 {
15011 if (temp2)
15012 delete arg2;
15013 }
15014 return NULL;
15015 }
15016
15017
15018 static PyObject *_wrap_DC_DrawImageLabel(PyObject *, PyObject *args, PyObject *kwargs) {
15019 PyObject *resultobj;
15020 wxDC *arg1 = (wxDC *) 0 ;
15021 wxString *arg2 = 0 ;
15022 wxBitmap *arg3 = 0 ;
15023 wxRect *arg4 = 0 ;
15024 int arg5 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
15025 int arg6 = (int) -1 ;
15026 wxRect result;
15027 bool temp2 = false ;
15028 wxRect temp4 ;
15029 PyObject * obj0 = 0 ;
15030 PyObject * obj1 = 0 ;
15031 PyObject * obj2 = 0 ;
15032 PyObject * obj3 = 0 ;
15033 PyObject * obj4 = 0 ;
15034 PyObject * obj5 = 0 ;
15035 char *kwnames[] = {
15036 (char *) "self",(char *) "text",(char *) "image",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
15037 };
15038
15039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:DC_DrawImageLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
15040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15041 if (SWIG_arg_fail(1)) SWIG_fail;
15042 {
15043 arg2 = wxString_in_helper(obj1);
15044 if (arg2 == NULL) SWIG_fail;
15045 temp2 = true;
15046 }
15047 {
15048 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
15049 if (SWIG_arg_fail(3)) SWIG_fail;
15050 if (arg3 == NULL) {
15051 SWIG_null_ref("wxBitmap");
15052 }
15053 if (SWIG_arg_fail(3)) SWIG_fail;
15054 }
15055 {
15056 arg4 = &temp4;
15057 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
15058 }
15059 if (obj4) {
15060 {
15061 arg5 = (int)(SWIG_As_int(obj4));
15062 if (SWIG_arg_fail(5)) SWIG_fail;
15063 }
15064 }
15065 if (obj5) {
15066 {
15067 arg6 = (int)(SWIG_As_int(obj5));
15068 if (SWIG_arg_fail(6)) SWIG_fail;
15069 }
15070 }
15071 {
15072 PyThreadState* __tstate = wxPyBeginAllowThreads();
15073 result = wxDC_DrawImageLabel(arg1,(wxString const &)*arg2,(wxBitmap const &)*arg3,(wxRect const &)*arg4,arg5,arg6);
15074
15075 wxPyEndAllowThreads(__tstate);
15076 if (PyErr_Occurred()) SWIG_fail;
15077 }
15078 {
15079 wxRect * resultptr;
15080 resultptr = new wxRect((wxRect &)(result));
15081 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
15082 }
15083 {
15084 if (temp2)
15085 delete arg2;
15086 }
15087 return resultobj;
15088 fail:
15089 {
15090 if (temp2)
15091 delete arg2;
15092 }
15093 return NULL;
15094 }
15095
15096
15097 static PyObject *_wrap_DC_DrawSpline(PyObject *, PyObject *args, PyObject *kwargs) {
15098 PyObject *resultobj;
15099 wxDC *arg1 = (wxDC *) 0 ;
15100 int arg2 ;
15101 wxPoint *arg3 = (wxPoint *) 0 ;
15102 PyObject * obj0 = 0 ;
15103 PyObject * obj1 = 0 ;
15104 char *kwnames[] = {
15105 (char *) "self",(char *) "points", NULL
15106 };
15107
15108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawSpline",kwnames,&obj0,&obj1)) goto fail;
15109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15110 if (SWIG_arg_fail(1)) SWIG_fail;
15111 {
15112 arg3 = wxPoint_LIST_helper(obj1, &arg2);
15113 if (arg3 == NULL) SWIG_fail;
15114 }
15115 {
15116 PyThreadState* __tstate = wxPyBeginAllowThreads();
15117 (arg1)->DrawSpline(arg2,arg3);
15118
15119 wxPyEndAllowThreads(__tstate);
15120 if (PyErr_Occurred()) SWIG_fail;
15121 }
15122 Py_INCREF(Py_None); resultobj = Py_None;
15123 {
15124 if (arg3) delete [] arg3;
15125 }
15126 return resultobj;
15127 fail:
15128 {
15129 if (arg3) delete [] arg3;
15130 }
15131 return NULL;
15132 }
15133
15134
15135 static PyObject *_wrap_DC_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
15136 PyObject *resultobj;
15137 wxDC *arg1 = (wxDC *) 0 ;
15138 PyObject * obj0 = 0 ;
15139 char *kwnames[] = {
15140 (char *) "self", NULL
15141 };
15142
15143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Clear",kwnames,&obj0)) goto fail;
15144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15145 if (SWIG_arg_fail(1)) SWIG_fail;
15146 {
15147 PyThreadState* __tstate = wxPyBeginAllowThreads();
15148 (arg1)->Clear();
15149
15150 wxPyEndAllowThreads(__tstate);
15151 if (PyErr_Occurred()) SWIG_fail;
15152 }
15153 Py_INCREF(Py_None); resultobj = Py_None;
15154 return resultobj;
15155 fail:
15156 return NULL;
15157 }
15158
15159
15160 static PyObject *_wrap_DC_StartDoc(PyObject *, PyObject *args, PyObject *kwargs) {
15161 PyObject *resultobj;
15162 wxDC *arg1 = (wxDC *) 0 ;
15163 wxString *arg2 = 0 ;
15164 bool result;
15165 bool temp2 = false ;
15166 PyObject * obj0 = 0 ;
15167 PyObject * obj1 = 0 ;
15168 char *kwnames[] = {
15169 (char *) "self",(char *) "message", NULL
15170 };
15171
15172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_StartDoc",kwnames,&obj0,&obj1)) goto fail;
15173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15174 if (SWIG_arg_fail(1)) SWIG_fail;
15175 {
15176 arg2 = wxString_in_helper(obj1);
15177 if (arg2 == NULL) SWIG_fail;
15178 temp2 = true;
15179 }
15180 {
15181 PyThreadState* __tstate = wxPyBeginAllowThreads();
15182 result = (bool)(arg1)->StartDoc((wxString const &)*arg2);
15183
15184 wxPyEndAllowThreads(__tstate);
15185 if (PyErr_Occurred()) SWIG_fail;
15186 }
15187 {
15188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15189 }
15190 {
15191 if (temp2)
15192 delete arg2;
15193 }
15194 return resultobj;
15195 fail:
15196 {
15197 if (temp2)
15198 delete arg2;
15199 }
15200 return NULL;
15201 }
15202
15203
15204 static PyObject *_wrap_DC_EndDoc(PyObject *, PyObject *args, PyObject *kwargs) {
15205 PyObject *resultobj;
15206 wxDC *arg1 = (wxDC *) 0 ;
15207 PyObject * obj0 = 0 ;
15208 char *kwnames[] = {
15209 (char *) "self", NULL
15210 };
15211
15212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDoc",kwnames,&obj0)) goto fail;
15213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15214 if (SWIG_arg_fail(1)) SWIG_fail;
15215 {
15216 PyThreadState* __tstate = wxPyBeginAllowThreads();
15217 (arg1)->EndDoc();
15218
15219 wxPyEndAllowThreads(__tstate);
15220 if (PyErr_Occurred()) SWIG_fail;
15221 }
15222 Py_INCREF(Py_None); resultobj = Py_None;
15223 return resultobj;
15224 fail:
15225 return NULL;
15226 }
15227
15228
15229 static PyObject *_wrap_DC_StartPage(PyObject *, PyObject *args, PyObject *kwargs) {
15230 PyObject *resultobj;
15231 wxDC *arg1 = (wxDC *) 0 ;
15232 PyObject * obj0 = 0 ;
15233 char *kwnames[] = {
15234 (char *) "self", NULL
15235 };
15236
15237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_StartPage",kwnames,&obj0)) goto fail;
15238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15239 if (SWIG_arg_fail(1)) SWIG_fail;
15240 {
15241 PyThreadState* __tstate = wxPyBeginAllowThreads();
15242 (arg1)->StartPage();
15243
15244 wxPyEndAllowThreads(__tstate);
15245 if (PyErr_Occurred()) SWIG_fail;
15246 }
15247 Py_INCREF(Py_None); resultobj = Py_None;
15248 return resultobj;
15249 fail:
15250 return NULL;
15251 }
15252
15253
15254 static PyObject *_wrap_DC_EndPage(PyObject *, PyObject *args, PyObject *kwargs) {
15255 PyObject *resultobj;
15256 wxDC *arg1 = (wxDC *) 0 ;
15257 PyObject * obj0 = 0 ;
15258 char *kwnames[] = {
15259 (char *) "self", NULL
15260 };
15261
15262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndPage",kwnames,&obj0)) goto fail;
15263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15264 if (SWIG_arg_fail(1)) SWIG_fail;
15265 {
15266 PyThreadState* __tstate = wxPyBeginAllowThreads();
15267 (arg1)->EndPage();
15268
15269 wxPyEndAllowThreads(__tstate);
15270 if (PyErr_Occurred()) SWIG_fail;
15271 }
15272 Py_INCREF(Py_None); resultobj = Py_None;
15273 return resultobj;
15274 fail:
15275 return NULL;
15276 }
15277
15278
15279 static PyObject *_wrap_DC_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
15280 PyObject *resultobj;
15281 wxDC *arg1 = (wxDC *) 0 ;
15282 wxFont *arg2 = 0 ;
15283 PyObject * obj0 = 0 ;
15284 PyObject * obj1 = 0 ;
15285 char *kwnames[] = {
15286 (char *) "self",(char *) "font", NULL
15287 };
15288
15289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetFont",kwnames,&obj0,&obj1)) goto fail;
15290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15291 if (SWIG_arg_fail(1)) SWIG_fail;
15292 {
15293 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15294 if (SWIG_arg_fail(2)) SWIG_fail;
15295 if (arg2 == NULL) {
15296 SWIG_null_ref("wxFont");
15297 }
15298 if (SWIG_arg_fail(2)) SWIG_fail;
15299 }
15300 {
15301 PyThreadState* __tstate = wxPyBeginAllowThreads();
15302 (arg1)->SetFont((wxFont const &)*arg2);
15303
15304 wxPyEndAllowThreads(__tstate);
15305 if (PyErr_Occurred()) SWIG_fail;
15306 }
15307 Py_INCREF(Py_None); resultobj = Py_None;
15308 return resultobj;
15309 fail:
15310 return NULL;
15311 }
15312
15313
15314 static PyObject *_wrap_DC_SetPen(PyObject *, PyObject *args, PyObject *kwargs) {
15315 PyObject *resultobj;
15316 wxDC *arg1 = (wxDC *) 0 ;
15317 wxPen *arg2 = 0 ;
15318 PyObject * obj0 = 0 ;
15319 PyObject * obj1 = 0 ;
15320 char *kwnames[] = {
15321 (char *) "self",(char *) "pen", NULL
15322 };
15323
15324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPen",kwnames,&obj0,&obj1)) goto fail;
15325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15326 if (SWIG_arg_fail(1)) SWIG_fail;
15327 {
15328 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
15329 if (SWIG_arg_fail(2)) SWIG_fail;
15330 if (arg2 == NULL) {
15331 SWIG_null_ref("wxPen");
15332 }
15333 if (SWIG_arg_fail(2)) SWIG_fail;
15334 }
15335 {
15336 PyThreadState* __tstate = wxPyBeginAllowThreads();
15337 (arg1)->SetPen((wxPen const &)*arg2);
15338
15339 wxPyEndAllowThreads(__tstate);
15340 if (PyErr_Occurred()) SWIG_fail;
15341 }
15342 Py_INCREF(Py_None); resultobj = Py_None;
15343 return resultobj;
15344 fail:
15345 return NULL;
15346 }
15347
15348
15349 static PyObject *_wrap_DC_SetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
15350 PyObject *resultobj;
15351 wxDC *arg1 = (wxDC *) 0 ;
15352 wxBrush *arg2 = 0 ;
15353 PyObject * obj0 = 0 ;
15354 PyObject * obj1 = 0 ;
15355 char *kwnames[] = {
15356 (char *) "self",(char *) "brush", NULL
15357 };
15358
15359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBrush",kwnames,&obj0,&obj1)) goto fail;
15360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15361 if (SWIG_arg_fail(1)) SWIG_fail;
15362 {
15363 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
15364 if (SWIG_arg_fail(2)) SWIG_fail;
15365 if (arg2 == NULL) {
15366 SWIG_null_ref("wxBrush");
15367 }
15368 if (SWIG_arg_fail(2)) SWIG_fail;
15369 }
15370 {
15371 PyThreadState* __tstate = wxPyBeginAllowThreads();
15372 (arg1)->SetBrush((wxBrush const &)*arg2);
15373
15374 wxPyEndAllowThreads(__tstate);
15375 if (PyErr_Occurred()) SWIG_fail;
15376 }
15377 Py_INCREF(Py_None); resultobj = Py_None;
15378 return resultobj;
15379 fail:
15380 return NULL;
15381 }
15382
15383
15384 static PyObject *_wrap_DC_SetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15385 PyObject *resultobj;
15386 wxDC *arg1 = (wxDC *) 0 ;
15387 wxBrush *arg2 = 0 ;
15388 PyObject * obj0 = 0 ;
15389 PyObject * obj1 = 0 ;
15390 char *kwnames[] = {
15391 (char *) "self",(char *) "brush", NULL
15392 };
15393
15394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackground",kwnames,&obj0,&obj1)) goto fail;
15395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15396 if (SWIG_arg_fail(1)) SWIG_fail;
15397 {
15398 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
15399 if (SWIG_arg_fail(2)) SWIG_fail;
15400 if (arg2 == NULL) {
15401 SWIG_null_ref("wxBrush");
15402 }
15403 if (SWIG_arg_fail(2)) SWIG_fail;
15404 }
15405 {
15406 PyThreadState* __tstate = wxPyBeginAllowThreads();
15407 (arg1)->SetBackground((wxBrush const &)*arg2);
15408
15409 wxPyEndAllowThreads(__tstate);
15410 if (PyErr_Occurred()) SWIG_fail;
15411 }
15412 Py_INCREF(Py_None); resultobj = Py_None;
15413 return resultobj;
15414 fail:
15415 return NULL;
15416 }
15417
15418
15419 static PyObject *_wrap_DC_SetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
15420 PyObject *resultobj;
15421 wxDC *arg1 = (wxDC *) 0 ;
15422 int arg2 ;
15423 PyObject * obj0 = 0 ;
15424 PyObject * obj1 = 0 ;
15425 char *kwnames[] = {
15426 (char *) "self",(char *) "mode", NULL
15427 };
15428
15429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackgroundMode",kwnames,&obj0,&obj1)) goto fail;
15430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15431 if (SWIG_arg_fail(1)) SWIG_fail;
15432 {
15433 arg2 = (int)(SWIG_As_int(obj1));
15434 if (SWIG_arg_fail(2)) SWIG_fail;
15435 }
15436 {
15437 PyThreadState* __tstate = wxPyBeginAllowThreads();
15438 (arg1)->SetBackgroundMode(arg2);
15439
15440 wxPyEndAllowThreads(__tstate);
15441 if (PyErr_Occurred()) SWIG_fail;
15442 }
15443 Py_INCREF(Py_None); resultobj = Py_None;
15444 return resultobj;
15445 fail:
15446 return NULL;
15447 }
15448
15449
15450 static PyObject *_wrap_DC_SetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
15451 PyObject *resultobj;
15452 wxDC *arg1 = (wxDC *) 0 ;
15453 wxPalette *arg2 = 0 ;
15454 PyObject * obj0 = 0 ;
15455 PyObject * obj1 = 0 ;
15456 char *kwnames[] = {
15457 (char *) "self",(char *) "palette", NULL
15458 };
15459
15460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPalette",kwnames,&obj0,&obj1)) goto fail;
15461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15462 if (SWIG_arg_fail(1)) SWIG_fail;
15463 {
15464 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
15465 if (SWIG_arg_fail(2)) SWIG_fail;
15466 if (arg2 == NULL) {
15467 SWIG_null_ref("wxPalette");
15468 }
15469 if (SWIG_arg_fail(2)) SWIG_fail;
15470 }
15471 {
15472 PyThreadState* __tstate = wxPyBeginAllowThreads();
15473 (arg1)->SetPalette((wxPalette const &)*arg2);
15474
15475 wxPyEndAllowThreads(__tstate);
15476 if (PyErr_Occurred()) SWIG_fail;
15477 }
15478 Py_INCREF(Py_None); resultobj = Py_None;
15479 return resultobj;
15480 fail:
15481 return NULL;
15482 }
15483
15484
15485 static PyObject *_wrap_DC_DestroyClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
15486 PyObject *resultobj;
15487 wxDC *arg1 = (wxDC *) 0 ;
15488 PyObject * obj0 = 0 ;
15489 char *kwnames[] = {
15490 (char *) "self", NULL
15491 };
15492
15493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_DestroyClippingRegion",kwnames,&obj0)) goto fail;
15494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15495 if (SWIG_arg_fail(1)) SWIG_fail;
15496 {
15497 PyThreadState* __tstate = wxPyBeginAllowThreads();
15498 (arg1)->DestroyClippingRegion();
15499
15500 wxPyEndAllowThreads(__tstate);
15501 if (PyErr_Occurred()) SWIG_fail;
15502 }
15503 Py_INCREF(Py_None); resultobj = Py_None;
15504 return resultobj;
15505 fail:
15506 return NULL;
15507 }
15508
15509
15510 static PyObject *_wrap_DC_GetClippingBox(PyObject *, PyObject *args, PyObject *kwargs) {
15511 PyObject *resultobj;
15512 wxDC *arg1 = (wxDC *) 0 ;
15513 int *arg2 = (int *) 0 ;
15514 int *arg3 = (int *) 0 ;
15515 int *arg4 = (int *) 0 ;
15516 int *arg5 = (int *) 0 ;
15517 int temp2 ;
15518 int res2 = 0 ;
15519 int temp3 ;
15520 int res3 = 0 ;
15521 int temp4 ;
15522 int res4 = 0 ;
15523 int temp5 ;
15524 int res5 = 0 ;
15525 PyObject * obj0 = 0 ;
15526 char *kwnames[] = {
15527 (char *) "self", NULL
15528 };
15529
15530 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15531 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15532 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15533 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingBox",kwnames,&obj0)) goto fail;
15535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15536 if (SWIG_arg_fail(1)) SWIG_fail;
15537 {
15538 PyThreadState* __tstate = wxPyBeginAllowThreads();
15539 ((wxDC const *)arg1)->GetClippingBox(arg2,arg3,arg4,arg5);
15540
15541 wxPyEndAllowThreads(__tstate);
15542 if (PyErr_Occurred()) SWIG_fail;
15543 }
15544 Py_INCREF(Py_None); resultobj = Py_None;
15545 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15546 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15547 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15548 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15549 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15550 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15551 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15552 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15553 return resultobj;
15554 fail:
15555 return NULL;
15556 }
15557
15558
15559 static PyObject *_wrap_DC_GetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
15560 PyObject *resultobj;
15561 wxDC *arg1 = (wxDC *) 0 ;
15562 wxRect result;
15563 PyObject * obj0 = 0 ;
15564 char *kwnames[] = {
15565 (char *) "self", NULL
15566 };
15567
15568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingRect",kwnames,&obj0)) goto fail;
15569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15570 if (SWIG_arg_fail(1)) SWIG_fail;
15571 {
15572 PyThreadState* __tstate = wxPyBeginAllowThreads();
15573 result = wxDC_GetClippingRect(arg1);
15574
15575 wxPyEndAllowThreads(__tstate);
15576 if (PyErr_Occurred()) SWIG_fail;
15577 }
15578 {
15579 wxRect * resultptr;
15580 resultptr = new wxRect((wxRect &)(result));
15581 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
15582 }
15583 return resultobj;
15584 fail:
15585 return NULL;
15586 }
15587
15588
15589 static PyObject *_wrap_DC_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
15590 PyObject *resultobj;
15591 wxDC *arg1 = (wxDC *) 0 ;
15592 int result;
15593 PyObject * obj0 = 0 ;
15594 char *kwnames[] = {
15595 (char *) "self", NULL
15596 };
15597
15598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharHeight",kwnames,&obj0)) goto fail;
15599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15600 if (SWIG_arg_fail(1)) SWIG_fail;
15601 {
15602 PyThreadState* __tstate = wxPyBeginAllowThreads();
15603 result = (int)((wxDC const *)arg1)->GetCharHeight();
15604
15605 wxPyEndAllowThreads(__tstate);
15606 if (PyErr_Occurred()) SWIG_fail;
15607 }
15608 {
15609 resultobj = SWIG_From_int((int)(result));
15610 }
15611 return resultobj;
15612 fail:
15613 return NULL;
15614 }
15615
15616
15617 static PyObject *_wrap_DC_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
15618 PyObject *resultobj;
15619 wxDC *arg1 = (wxDC *) 0 ;
15620 int result;
15621 PyObject * obj0 = 0 ;
15622 char *kwnames[] = {
15623 (char *) "self", NULL
15624 };
15625
15626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharWidth",kwnames,&obj0)) goto fail;
15627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15628 if (SWIG_arg_fail(1)) SWIG_fail;
15629 {
15630 PyThreadState* __tstate = wxPyBeginAllowThreads();
15631 result = (int)((wxDC const *)arg1)->GetCharWidth();
15632
15633 wxPyEndAllowThreads(__tstate);
15634 if (PyErr_Occurred()) SWIG_fail;
15635 }
15636 {
15637 resultobj = SWIG_From_int((int)(result));
15638 }
15639 return resultobj;
15640 fail:
15641 return NULL;
15642 }
15643
15644
15645 static PyObject *_wrap_DC_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15646 PyObject *resultobj;
15647 wxDC *arg1 = (wxDC *) 0 ;
15648 wxString *arg2 = 0 ;
15649 int *arg3 = (int *) 0 ;
15650 int *arg4 = (int *) 0 ;
15651 bool temp2 = false ;
15652 int temp3 ;
15653 int res3 = 0 ;
15654 int temp4 ;
15655 int res4 = 0 ;
15656 PyObject * obj0 = 0 ;
15657 PyObject * obj1 = 0 ;
15658 char *kwnames[] = {
15659 (char *) "self",(char *) "string", NULL
15660 };
15661
15662 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15663 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
15665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15666 if (SWIG_arg_fail(1)) SWIG_fail;
15667 {
15668 arg2 = wxString_in_helper(obj1);
15669 if (arg2 == NULL) SWIG_fail;
15670 temp2 = true;
15671 }
15672 {
15673 PyThreadState* __tstate = wxPyBeginAllowThreads();
15674 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
15675
15676 wxPyEndAllowThreads(__tstate);
15677 if (PyErr_Occurred()) SWIG_fail;
15678 }
15679 Py_INCREF(Py_None); resultobj = Py_None;
15680 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15681 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15682 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15683 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15684 {
15685 if (temp2)
15686 delete arg2;
15687 }
15688 return resultobj;
15689 fail:
15690 {
15691 if (temp2)
15692 delete arg2;
15693 }
15694 return NULL;
15695 }
15696
15697
15698 static PyObject *_wrap_DC_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15699 PyObject *resultobj;
15700 wxDC *arg1 = (wxDC *) 0 ;
15701 wxString *arg2 = 0 ;
15702 int *arg3 = (int *) 0 ;
15703 int *arg4 = (int *) 0 ;
15704 int *arg5 = (int *) 0 ;
15705 int *arg6 = (int *) 0 ;
15706 wxFont *arg7 = (wxFont *) NULL ;
15707 bool temp2 = false ;
15708 int temp3 ;
15709 int res3 = 0 ;
15710 int temp4 ;
15711 int res4 = 0 ;
15712 int temp5 ;
15713 int res5 = 0 ;
15714 int temp6 ;
15715 int res6 = 0 ;
15716 PyObject * obj0 = 0 ;
15717 PyObject * obj1 = 0 ;
15718 PyObject * obj2 = 0 ;
15719 char *kwnames[] = {
15720 (char *) "self",(char *) "string",(char *) "font", NULL
15721 };
15722
15723 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15724 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15725 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15726 arg6 = &temp6; res6 = SWIG_NEWOBJ;
15727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15729 if (SWIG_arg_fail(1)) SWIG_fail;
15730 {
15731 arg2 = wxString_in_helper(obj1);
15732 if (arg2 == NULL) SWIG_fail;
15733 temp2 = true;
15734 }
15735 if (obj2) {
15736 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15737 if (SWIG_arg_fail(7)) SWIG_fail;
15738 }
15739 {
15740 PyThreadState* __tstate = wxPyBeginAllowThreads();
15741 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
15742
15743 wxPyEndAllowThreads(__tstate);
15744 if (PyErr_Occurred()) SWIG_fail;
15745 }
15746 Py_INCREF(Py_None); resultobj = Py_None;
15747 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15748 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15749 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15750 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15751 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15752 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15753 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
15754 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
15755 {
15756 if (temp2)
15757 delete arg2;
15758 }
15759 return resultobj;
15760 fail:
15761 {
15762 if (temp2)
15763 delete arg2;
15764 }
15765 return NULL;
15766 }
15767
15768
15769 static PyObject *_wrap_DC_GetMultiLineTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15770 PyObject *resultobj;
15771 wxDC *arg1 = (wxDC *) 0 ;
15772 wxString *arg2 = 0 ;
15773 int *arg3 = (int *) 0 ;
15774 int *arg4 = (int *) 0 ;
15775 int *arg5 = (int *) 0 ;
15776 wxFont *arg6 = (wxFont *) NULL ;
15777 bool temp2 = false ;
15778 int temp3 ;
15779 int res3 = 0 ;
15780 int temp4 ;
15781 int res4 = 0 ;
15782 int temp5 ;
15783 int res5 = 0 ;
15784 PyObject * obj0 = 0 ;
15785 PyObject * obj1 = 0 ;
15786 PyObject * obj2 = 0 ;
15787 char *kwnames[] = {
15788 (char *) "self",(char *) "text",(char *) "font", NULL
15789 };
15790
15791 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15792 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15793 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetMultiLineTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15796 if (SWIG_arg_fail(1)) SWIG_fail;
15797 {
15798 arg2 = wxString_in_helper(obj1);
15799 if (arg2 == NULL) SWIG_fail;
15800 temp2 = true;
15801 }
15802 if (obj2) {
15803 SWIG_Python_ConvertPtr(obj2, (void **)&arg6, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15804 if (SWIG_arg_fail(6)) SWIG_fail;
15805 }
15806 {
15807 PyThreadState* __tstate = wxPyBeginAllowThreads();
15808 (arg1)->GetMultiLineTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6);
15809
15810 wxPyEndAllowThreads(__tstate);
15811 if (PyErr_Occurred()) SWIG_fail;
15812 }
15813 Py_INCREF(Py_None); resultobj = Py_None;
15814 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15815 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15816 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15817 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15818 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15819 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15820 {
15821 if (temp2)
15822 delete arg2;
15823 }
15824 return resultobj;
15825 fail:
15826 {
15827 if (temp2)
15828 delete arg2;
15829 }
15830 return NULL;
15831 }
15832
15833
15834 static PyObject *_wrap_DC_GetPartialTextExtents(PyObject *, PyObject *args, PyObject *kwargs) {
15835 PyObject *resultobj;
15836 wxDC *arg1 = (wxDC *) 0 ;
15837 wxString *arg2 = 0 ;
15838 wxArrayInt result;
15839 bool temp2 = false ;
15840 PyObject * obj0 = 0 ;
15841 PyObject * obj1 = 0 ;
15842 char *kwnames[] = {
15843 (char *) "self",(char *) "text", NULL
15844 };
15845
15846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPartialTextExtents",kwnames,&obj0,&obj1)) goto fail;
15847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15848 if (SWIG_arg_fail(1)) SWIG_fail;
15849 {
15850 arg2 = wxString_in_helper(obj1);
15851 if (arg2 == NULL) SWIG_fail;
15852 temp2 = true;
15853 }
15854 {
15855 PyThreadState* __tstate = wxPyBeginAllowThreads();
15856 result = wxDC_GetPartialTextExtents(arg1,(wxString const &)*arg2);
15857
15858 wxPyEndAllowThreads(__tstate);
15859 if (PyErr_Occurred()) SWIG_fail;
15860 }
15861 {
15862 resultobj = PyList_New(0);
15863 size_t idx;
15864 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15865 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15866 PyList_Append(resultobj, val);
15867 Py_DECREF(val);
15868 }
15869 }
15870 {
15871 if (temp2)
15872 delete arg2;
15873 }
15874 return resultobj;
15875 fail:
15876 {
15877 if (temp2)
15878 delete arg2;
15879 }
15880 return NULL;
15881 }
15882
15883
15884 static PyObject *_wrap_DC_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
15885 PyObject *resultobj;
15886 wxDC *arg1 = (wxDC *) 0 ;
15887 wxSize result;
15888 PyObject * obj0 = 0 ;
15889 char *kwnames[] = {
15890 (char *) "self", NULL
15891 };
15892
15893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSize",kwnames,&obj0)) goto fail;
15894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15895 if (SWIG_arg_fail(1)) SWIG_fail;
15896 {
15897 PyThreadState* __tstate = wxPyBeginAllowThreads();
15898 result = (arg1)->GetSize();
15899
15900 wxPyEndAllowThreads(__tstate);
15901 if (PyErr_Occurred()) SWIG_fail;
15902 }
15903 {
15904 wxSize * resultptr;
15905 resultptr = new wxSize((wxSize &)(result));
15906 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15907 }
15908 return resultobj;
15909 fail:
15910 return NULL;
15911 }
15912
15913
15914 static PyObject *_wrap_DC_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15915 PyObject *resultobj;
15916 wxDC *arg1 = (wxDC *) 0 ;
15917 int *arg2 = (int *) 0 ;
15918 int *arg3 = (int *) 0 ;
15919 int temp2 ;
15920 int res2 = 0 ;
15921 int temp3 ;
15922 int res3 = 0 ;
15923 PyObject * obj0 = 0 ;
15924 char *kwnames[] = {
15925 (char *) "self", NULL
15926 };
15927
15928 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15929 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeTuple",kwnames,&obj0)) goto fail;
15931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15932 if (SWIG_arg_fail(1)) SWIG_fail;
15933 {
15934 PyThreadState* __tstate = wxPyBeginAllowThreads();
15935 (arg1)->GetSize(arg2,arg3);
15936
15937 wxPyEndAllowThreads(__tstate);
15938 if (PyErr_Occurred()) SWIG_fail;
15939 }
15940 Py_INCREF(Py_None); resultobj = Py_None;
15941 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15942 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15943 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15944 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15945 return resultobj;
15946 fail:
15947 return NULL;
15948 }
15949
15950
15951 static PyObject *_wrap_DC_GetSizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
15952 PyObject *resultobj;
15953 wxDC *arg1 = (wxDC *) 0 ;
15954 wxSize result;
15955 PyObject * obj0 = 0 ;
15956 char *kwnames[] = {
15957 (char *) "self", NULL
15958 };
15959
15960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMM",kwnames,&obj0)) goto fail;
15961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15962 if (SWIG_arg_fail(1)) SWIG_fail;
15963 {
15964 PyThreadState* __tstate = wxPyBeginAllowThreads();
15965 result = ((wxDC const *)arg1)->GetSizeMM();
15966
15967 wxPyEndAllowThreads(__tstate);
15968 if (PyErr_Occurred()) SWIG_fail;
15969 }
15970 {
15971 wxSize * resultptr;
15972 resultptr = new wxSize((wxSize &)(result));
15973 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15974 }
15975 return resultobj;
15976 fail:
15977 return NULL;
15978 }
15979
15980
15981 static PyObject *_wrap_DC_GetSizeMMTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15982 PyObject *resultobj;
15983 wxDC *arg1 = (wxDC *) 0 ;
15984 int *arg2 = (int *) 0 ;
15985 int *arg3 = (int *) 0 ;
15986 int temp2 ;
15987 int res2 = 0 ;
15988 int temp3 ;
15989 int res3 = 0 ;
15990 PyObject * obj0 = 0 ;
15991 char *kwnames[] = {
15992 (char *) "self", NULL
15993 };
15994
15995 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15996 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMMTuple",kwnames,&obj0)) goto fail;
15998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15999 if (SWIG_arg_fail(1)) SWIG_fail;
16000 {
16001 PyThreadState* __tstate = wxPyBeginAllowThreads();
16002 ((wxDC const *)arg1)->GetSizeMM(arg2,arg3);
16003
16004 wxPyEndAllowThreads(__tstate);
16005 if (PyErr_Occurred()) SWIG_fail;
16006 }
16007 Py_INCREF(Py_None); resultobj = Py_None;
16008 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16009 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16010 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16011 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16012 return resultobj;
16013 fail:
16014 return NULL;
16015 }
16016
16017
16018 static PyObject *_wrap_DC_DeviceToLogicalX(PyObject *, PyObject *args, PyObject *kwargs) {
16019 PyObject *resultobj;
16020 wxDC *arg1 = (wxDC *) 0 ;
16021 int arg2 ;
16022 int result;
16023 PyObject * obj0 = 0 ;
16024 PyObject * obj1 = 0 ;
16025 char *kwnames[] = {
16026 (char *) "self",(char *) "x", NULL
16027 };
16028
16029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalX",kwnames,&obj0,&obj1)) goto fail;
16030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16031 if (SWIG_arg_fail(1)) SWIG_fail;
16032 {
16033 arg2 = (int)(SWIG_As_int(obj1));
16034 if (SWIG_arg_fail(2)) SWIG_fail;
16035 }
16036 {
16037 PyThreadState* __tstate = wxPyBeginAllowThreads();
16038 result = (int)((wxDC const *)arg1)->DeviceToLogicalX(arg2);
16039
16040 wxPyEndAllowThreads(__tstate);
16041 if (PyErr_Occurred()) SWIG_fail;
16042 }
16043 {
16044 resultobj = SWIG_From_int((int)(result));
16045 }
16046 return resultobj;
16047 fail:
16048 return NULL;
16049 }
16050
16051
16052 static PyObject *_wrap_DC_DeviceToLogicalY(PyObject *, PyObject *args, PyObject *kwargs) {
16053 PyObject *resultobj;
16054 wxDC *arg1 = (wxDC *) 0 ;
16055 int arg2 ;
16056 int result;
16057 PyObject * obj0 = 0 ;
16058 PyObject * obj1 = 0 ;
16059 char *kwnames[] = {
16060 (char *) "self",(char *) "y", NULL
16061 };
16062
16063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalY",kwnames,&obj0,&obj1)) goto fail;
16064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16065 if (SWIG_arg_fail(1)) SWIG_fail;
16066 {
16067 arg2 = (int)(SWIG_As_int(obj1));
16068 if (SWIG_arg_fail(2)) SWIG_fail;
16069 }
16070 {
16071 PyThreadState* __tstate = wxPyBeginAllowThreads();
16072 result = (int)((wxDC const *)arg1)->DeviceToLogicalY(arg2);
16073
16074 wxPyEndAllowThreads(__tstate);
16075 if (PyErr_Occurred()) SWIG_fail;
16076 }
16077 {
16078 resultobj = SWIG_From_int((int)(result));
16079 }
16080 return resultobj;
16081 fail:
16082 return NULL;
16083 }
16084
16085
16086 static PyObject *_wrap_DC_DeviceToLogicalXRel(PyObject *, PyObject *args, PyObject *kwargs) {
16087 PyObject *resultobj;
16088 wxDC *arg1 = (wxDC *) 0 ;
16089 int arg2 ;
16090 int result;
16091 PyObject * obj0 = 0 ;
16092 PyObject * obj1 = 0 ;
16093 char *kwnames[] = {
16094 (char *) "self",(char *) "x", NULL
16095 };
16096
16097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalXRel",kwnames,&obj0,&obj1)) goto fail;
16098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16099 if (SWIG_arg_fail(1)) SWIG_fail;
16100 {
16101 arg2 = (int)(SWIG_As_int(obj1));
16102 if (SWIG_arg_fail(2)) SWIG_fail;
16103 }
16104 {
16105 PyThreadState* __tstate = wxPyBeginAllowThreads();
16106 result = (int)((wxDC const *)arg1)->DeviceToLogicalXRel(arg2);
16107
16108 wxPyEndAllowThreads(__tstate);
16109 if (PyErr_Occurred()) SWIG_fail;
16110 }
16111 {
16112 resultobj = SWIG_From_int((int)(result));
16113 }
16114 return resultobj;
16115 fail:
16116 return NULL;
16117 }
16118
16119
16120 static PyObject *_wrap_DC_DeviceToLogicalYRel(PyObject *, PyObject *args, PyObject *kwargs) {
16121 PyObject *resultobj;
16122 wxDC *arg1 = (wxDC *) 0 ;
16123 int arg2 ;
16124 int result;
16125 PyObject * obj0 = 0 ;
16126 PyObject * obj1 = 0 ;
16127 char *kwnames[] = {
16128 (char *) "self",(char *) "y", NULL
16129 };
16130
16131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalYRel",kwnames,&obj0,&obj1)) goto fail;
16132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16133 if (SWIG_arg_fail(1)) SWIG_fail;
16134 {
16135 arg2 = (int)(SWIG_As_int(obj1));
16136 if (SWIG_arg_fail(2)) SWIG_fail;
16137 }
16138 {
16139 PyThreadState* __tstate = wxPyBeginAllowThreads();
16140 result = (int)((wxDC const *)arg1)->DeviceToLogicalYRel(arg2);
16141
16142 wxPyEndAllowThreads(__tstate);
16143 if (PyErr_Occurred()) SWIG_fail;
16144 }
16145 {
16146 resultobj = SWIG_From_int((int)(result));
16147 }
16148 return resultobj;
16149 fail:
16150 return NULL;
16151 }
16152
16153
16154 static PyObject *_wrap_DC_LogicalToDeviceX(PyObject *, PyObject *args, PyObject *kwargs) {
16155 PyObject *resultobj;
16156 wxDC *arg1 = (wxDC *) 0 ;
16157 int arg2 ;
16158 int result;
16159 PyObject * obj0 = 0 ;
16160 PyObject * obj1 = 0 ;
16161 char *kwnames[] = {
16162 (char *) "self",(char *) "x", NULL
16163 };
16164
16165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceX",kwnames,&obj0,&obj1)) goto fail;
16166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16167 if (SWIG_arg_fail(1)) SWIG_fail;
16168 {
16169 arg2 = (int)(SWIG_As_int(obj1));
16170 if (SWIG_arg_fail(2)) SWIG_fail;
16171 }
16172 {
16173 PyThreadState* __tstate = wxPyBeginAllowThreads();
16174 result = (int)((wxDC const *)arg1)->LogicalToDeviceX(arg2);
16175
16176 wxPyEndAllowThreads(__tstate);
16177 if (PyErr_Occurred()) SWIG_fail;
16178 }
16179 {
16180 resultobj = SWIG_From_int((int)(result));
16181 }
16182 return resultobj;
16183 fail:
16184 return NULL;
16185 }
16186
16187
16188 static PyObject *_wrap_DC_LogicalToDeviceY(PyObject *, PyObject *args, PyObject *kwargs) {
16189 PyObject *resultobj;
16190 wxDC *arg1 = (wxDC *) 0 ;
16191 int arg2 ;
16192 int result;
16193 PyObject * obj0 = 0 ;
16194 PyObject * obj1 = 0 ;
16195 char *kwnames[] = {
16196 (char *) "self",(char *) "y", NULL
16197 };
16198
16199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceY",kwnames,&obj0,&obj1)) goto fail;
16200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16201 if (SWIG_arg_fail(1)) SWIG_fail;
16202 {
16203 arg2 = (int)(SWIG_As_int(obj1));
16204 if (SWIG_arg_fail(2)) SWIG_fail;
16205 }
16206 {
16207 PyThreadState* __tstate = wxPyBeginAllowThreads();
16208 result = (int)((wxDC const *)arg1)->LogicalToDeviceY(arg2);
16209
16210 wxPyEndAllowThreads(__tstate);
16211 if (PyErr_Occurred()) SWIG_fail;
16212 }
16213 {
16214 resultobj = SWIG_From_int((int)(result));
16215 }
16216 return resultobj;
16217 fail:
16218 return NULL;
16219 }
16220
16221
16222 static PyObject *_wrap_DC_LogicalToDeviceXRel(PyObject *, PyObject *args, PyObject *kwargs) {
16223 PyObject *resultobj;
16224 wxDC *arg1 = (wxDC *) 0 ;
16225 int arg2 ;
16226 int result;
16227 PyObject * obj0 = 0 ;
16228 PyObject * obj1 = 0 ;
16229 char *kwnames[] = {
16230 (char *) "self",(char *) "x", NULL
16231 };
16232
16233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceXRel",kwnames,&obj0,&obj1)) goto fail;
16234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16235 if (SWIG_arg_fail(1)) SWIG_fail;
16236 {
16237 arg2 = (int)(SWIG_As_int(obj1));
16238 if (SWIG_arg_fail(2)) SWIG_fail;
16239 }
16240 {
16241 PyThreadState* __tstate = wxPyBeginAllowThreads();
16242 result = (int)((wxDC const *)arg1)->LogicalToDeviceXRel(arg2);
16243
16244 wxPyEndAllowThreads(__tstate);
16245 if (PyErr_Occurred()) SWIG_fail;
16246 }
16247 {
16248 resultobj = SWIG_From_int((int)(result));
16249 }
16250 return resultobj;
16251 fail:
16252 return NULL;
16253 }
16254
16255
16256 static PyObject *_wrap_DC_LogicalToDeviceYRel(PyObject *, PyObject *args, PyObject *kwargs) {
16257 PyObject *resultobj;
16258 wxDC *arg1 = (wxDC *) 0 ;
16259 int arg2 ;
16260 int result;
16261 PyObject * obj0 = 0 ;
16262 PyObject * obj1 = 0 ;
16263 char *kwnames[] = {
16264 (char *) "self",(char *) "y", NULL
16265 };
16266
16267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceYRel",kwnames,&obj0,&obj1)) goto fail;
16268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16269 if (SWIG_arg_fail(1)) SWIG_fail;
16270 {
16271 arg2 = (int)(SWIG_As_int(obj1));
16272 if (SWIG_arg_fail(2)) SWIG_fail;
16273 }
16274 {
16275 PyThreadState* __tstate = wxPyBeginAllowThreads();
16276 result = (int)((wxDC const *)arg1)->LogicalToDeviceYRel(arg2);
16277
16278 wxPyEndAllowThreads(__tstate);
16279 if (PyErr_Occurred()) SWIG_fail;
16280 }
16281 {
16282 resultobj = SWIG_From_int((int)(result));
16283 }
16284 return resultobj;
16285 fail:
16286 return NULL;
16287 }
16288
16289
16290 static PyObject *_wrap_DC_CanDrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16291 PyObject *resultobj;
16292 wxDC *arg1 = (wxDC *) 0 ;
16293 bool result;
16294 PyObject * obj0 = 0 ;
16295 char *kwnames[] = {
16296 (char *) "self", NULL
16297 };
16298
16299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanDrawBitmap",kwnames,&obj0)) goto fail;
16300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16301 if (SWIG_arg_fail(1)) SWIG_fail;
16302 {
16303 PyThreadState* __tstate = wxPyBeginAllowThreads();
16304 result = (bool)((wxDC const *)arg1)->CanDrawBitmap();
16305
16306 wxPyEndAllowThreads(__tstate);
16307 if (PyErr_Occurred()) SWIG_fail;
16308 }
16309 {
16310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16311 }
16312 return resultobj;
16313 fail:
16314 return NULL;
16315 }
16316
16317
16318 static PyObject *_wrap_DC_CanGetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
16319 PyObject *resultobj;
16320 wxDC *arg1 = (wxDC *) 0 ;
16321 bool result;
16322 PyObject * obj0 = 0 ;
16323 char *kwnames[] = {
16324 (char *) "self", NULL
16325 };
16326
16327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanGetTextExtent",kwnames,&obj0)) goto fail;
16328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16329 if (SWIG_arg_fail(1)) SWIG_fail;
16330 {
16331 PyThreadState* __tstate = wxPyBeginAllowThreads();
16332 result = (bool)((wxDC const *)arg1)->CanGetTextExtent();
16333
16334 wxPyEndAllowThreads(__tstate);
16335 if (PyErr_Occurred()) SWIG_fail;
16336 }
16337 {
16338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16339 }
16340 return resultobj;
16341 fail:
16342 return NULL;
16343 }
16344
16345
16346 static PyObject *_wrap_DC_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
16347 PyObject *resultobj;
16348 wxDC *arg1 = (wxDC *) 0 ;
16349 int result;
16350 PyObject * obj0 = 0 ;
16351 char *kwnames[] = {
16352 (char *) "self", NULL
16353 };
16354
16355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDepth",kwnames,&obj0)) goto fail;
16356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16357 if (SWIG_arg_fail(1)) SWIG_fail;
16358 {
16359 PyThreadState* __tstate = wxPyBeginAllowThreads();
16360 result = (int)((wxDC const *)arg1)->GetDepth();
16361
16362 wxPyEndAllowThreads(__tstate);
16363 if (PyErr_Occurred()) SWIG_fail;
16364 }
16365 {
16366 resultobj = SWIG_From_int((int)(result));
16367 }
16368 return resultobj;
16369 fail:
16370 return NULL;
16371 }
16372
16373
16374 static PyObject *_wrap_DC_GetPPI(PyObject *, PyObject *args, PyObject *kwargs) {
16375 PyObject *resultobj;
16376 wxDC *arg1 = (wxDC *) 0 ;
16377 wxSize result;
16378 PyObject * obj0 = 0 ;
16379 char *kwnames[] = {
16380 (char *) "self", NULL
16381 };
16382
16383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPPI",kwnames,&obj0)) goto fail;
16384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16385 if (SWIG_arg_fail(1)) SWIG_fail;
16386 {
16387 PyThreadState* __tstate = wxPyBeginAllowThreads();
16388 result = ((wxDC const *)arg1)->GetPPI();
16389
16390 wxPyEndAllowThreads(__tstate);
16391 if (PyErr_Occurred()) SWIG_fail;
16392 }
16393 {
16394 wxSize * resultptr;
16395 resultptr = new wxSize((wxSize &)(result));
16396 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16397 }
16398 return resultobj;
16399 fail:
16400 return NULL;
16401 }
16402
16403
16404 static PyObject *_wrap_DC_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
16405 PyObject *resultobj;
16406 wxDC *arg1 = (wxDC *) 0 ;
16407 bool result;
16408 PyObject * obj0 = 0 ;
16409 char *kwnames[] = {
16410 (char *) "self", NULL
16411 };
16412
16413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Ok",kwnames,&obj0)) goto fail;
16414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16415 if (SWIG_arg_fail(1)) SWIG_fail;
16416 {
16417 PyThreadState* __tstate = wxPyBeginAllowThreads();
16418 result = (bool)((wxDC const *)arg1)->Ok();
16419
16420 wxPyEndAllowThreads(__tstate);
16421 if (PyErr_Occurred()) SWIG_fail;
16422 }
16423 {
16424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16425 }
16426 return resultobj;
16427 fail:
16428 return NULL;
16429 }
16430
16431
16432 static PyObject *_wrap_DC_GetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
16433 PyObject *resultobj;
16434 wxDC *arg1 = (wxDC *) 0 ;
16435 int result;
16436 PyObject * obj0 = 0 ;
16437 char *kwnames[] = {
16438 (char *) "self", NULL
16439 };
16440
16441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackgroundMode",kwnames,&obj0)) goto fail;
16442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16443 if (SWIG_arg_fail(1)) SWIG_fail;
16444 {
16445 PyThreadState* __tstate = wxPyBeginAllowThreads();
16446 result = (int)((wxDC const *)arg1)->GetBackgroundMode();
16447
16448 wxPyEndAllowThreads(__tstate);
16449 if (PyErr_Occurred()) SWIG_fail;
16450 }
16451 {
16452 resultobj = SWIG_From_int((int)(result));
16453 }
16454 return resultobj;
16455 fail:
16456 return NULL;
16457 }
16458
16459
16460 static PyObject *_wrap_DC_GetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16461 PyObject *resultobj;
16462 wxDC *arg1 = (wxDC *) 0 ;
16463 wxBrush *result;
16464 PyObject * obj0 = 0 ;
16465 char *kwnames[] = {
16466 (char *) "self", NULL
16467 };
16468
16469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackground",kwnames,&obj0)) goto fail;
16470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16471 if (SWIG_arg_fail(1)) SWIG_fail;
16472 {
16473 PyThreadState* __tstate = wxPyBeginAllowThreads();
16474 {
16475 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBackground();
16476 result = (wxBrush *) &_result_ref;
16477 }
16478
16479 wxPyEndAllowThreads(__tstate);
16480 if (PyErr_Occurred()) SWIG_fail;
16481 }
16482 {
16483 wxBrush* resultptr = new wxBrush(*result);
16484 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
16485 }
16486 return resultobj;
16487 fail:
16488 return NULL;
16489 }
16490
16491
16492 static PyObject *_wrap_DC_GetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
16493 PyObject *resultobj;
16494 wxDC *arg1 = (wxDC *) 0 ;
16495 wxBrush *result;
16496 PyObject * obj0 = 0 ;
16497 char *kwnames[] = {
16498 (char *) "self", NULL
16499 };
16500
16501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBrush",kwnames,&obj0)) goto fail;
16502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16503 if (SWIG_arg_fail(1)) SWIG_fail;
16504 {
16505 PyThreadState* __tstate = wxPyBeginAllowThreads();
16506 {
16507 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBrush();
16508 result = (wxBrush *) &_result_ref;
16509 }
16510
16511 wxPyEndAllowThreads(__tstate);
16512 if (PyErr_Occurred()) SWIG_fail;
16513 }
16514 {
16515 wxBrush* resultptr = new wxBrush(*result);
16516 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
16517 }
16518 return resultobj;
16519 fail:
16520 return NULL;
16521 }
16522
16523
16524 static PyObject *_wrap_DC_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
16525 PyObject *resultobj;
16526 wxDC *arg1 = (wxDC *) 0 ;
16527 wxFont *result;
16528 PyObject * obj0 = 0 ;
16529 char *kwnames[] = {
16530 (char *) "self", NULL
16531 };
16532
16533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetFont",kwnames,&obj0)) goto fail;
16534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16535 if (SWIG_arg_fail(1)) SWIG_fail;
16536 {
16537 PyThreadState* __tstate = wxPyBeginAllowThreads();
16538 {
16539 wxFont const &_result_ref = ((wxDC const *)arg1)->GetFont();
16540 result = (wxFont *) &_result_ref;
16541 }
16542
16543 wxPyEndAllowThreads(__tstate);
16544 if (PyErr_Occurred()) SWIG_fail;
16545 }
16546 {
16547 wxFont* resultptr = new wxFont(*result);
16548 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxFont, 1);
16549 }
16550 return resultobj;
16551 fail:
16552 return NULL;
16553 }
16554
16555
16556 static PyObject *_wrap_DC_GetPen(PyObject *, PyObject *args, PyObject *kwargs) {
16557 PyObject *resultobj;
16558 wxDC *arg1 = (wxDC *) 0 ;
16559 wxPen *result;
16560 PyObject * obj0 = 0 ;
16561 char *kwnames[] = {
16562 (char *) "self", NULL
16563 };
16564
16565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPen",kwnames,&obj0)) goto fail;
16566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16567 if (SWIG_arg_fail(1)) SWIG_fail;
16568 {
16569 PyThreadState* __tstate = wxPyBeginAllowThreads();
16570 {
16571 wxPen const &_result_ref = ((wxDC const *)arg1)->GetPen();
16572 result = (wxPen *) &_result_ref;
16573 }
16574
16575 wxPyEndAllowThreads(__tstate);
16576 if (PyErr_Occurred()) SWIG_fail;
16577 }
16578 {
16579 wxPen* resultptr = new wxPen(*result);
16580 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxPen, 1);
16581 }
16582 return resultobj;
16583 fail:
16584 return NULL;
16585 }
16586
16587
16588 static PyObject *_wrap_DC_GetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16589 PyObject *resultobj;
16590 wxDC *arg1 = (wxDC *) 0 ;
16591 wxColour *result;
16592 PyObject * obj0 = 0 ;
16593 char *kwnames[] = {
16594 (char *) "self", NULL
16595 };
16596
16597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextBackground",kwnames,&obj0)) goto fail;
16598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16599 if (SWIG_arg_fail(1)) SWIG_fail;
16600 {
16601 PyThreadState* __tstate = wxPyBeginAllowThreads();
16602 {
16603 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextBackground();
16604 result = (wxColour *) &_result_ref;
16605 }
16606
16607 wxPyEndAllowThreads(__tstate);
16608 if (PyErr_Occurred()) SWIG_fail;
16609 }
16610 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
16611 return resultobj;
16612 fail:
16613 return NULL;
16614 }
16615
16616
16617 static PyObject *_wrap_DC_GetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16618 PyObject *resultobj;
16619 wxDC *arg1 = (wxDC *) 0 ;
16620 wxColour *result;
16621 PyObject * obj0 = 0 ;
16622 char *kwnames[] = {
16623 (char *) "self", NULL
16624 };
16625
16626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextForeground",kwnames,&obj0)) goto fail;
16627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16628 if (SWIG_arg_fail(1)) SWIG_fail;
16629 {
16630 PyThreadState* __tstate = wxPyBeginAllowThreads();
16631 {
16632 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextForeground();
16633 result = (wxColour *) &_result_ref;
16634 }
16635
16636 wxPyEndAllowThreads(__tstate);
16637 if (PyErr_Occurred()) SWIG_fail;
16638 }
16639 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
16640 return resultobj;
16641 fail:
16642 return NULL;
16643 }
16644
16645
16646 static PyObject *_wrap_DC_SetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16647 PyObject *resultobj;
16648 wxDC *arg1 = (wxDC *) 0 ;
16649 wxColour *arg2 = 0 ;
16650 wxColour temp2 ;
16651 PyObject * obj0 = 0 ;
16652 PyObject * obj1 = 0 ;
16653 char *kwnames[] = {
16654 (char *) "self",(char *) "colour", NULL
16655 };
16656
16657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextForeground",kwnames,&obj0,&obj1)) goto fail;
16658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16659 if (SWIG_arg_fail(1)) SWIG_fail;
16660 {
16661 arg2 = &temp2;
16662 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16663 }
16664 {
16665 PyThreadState* __tstate = wxPyBeginAllowThreads();
16666 (arg1)->SetTextForeground((wxColour const &)*arg2);
16667
16668 wxPyEndAllowThreads(__tstate);
16669 if (PyErr_Occurred()) SWIG_fail;
16670 }
16671 Py_INCREF(Py_None); resultobj = Py_None;
16672 return resultobj;
16673 fail:
16674 return NULL;
16675 }
16676
16677
16678 static PyObject *_wrap_DC_SetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16679 PyObject *resultobj;
16680 wxDC *arg1 = (wxDC *) 0 ;
16681 wxColour *arg2 = 0 ;
16682 wxColour temp2 ;
16683 PyObject * obj0 = 0 ;
16684 PyObject * obj1 = 0 ;
16685 char *kwnames[] = {
16686 (char *) "self",(char *) "colour", NULL
16687 };
16688
16689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextBackground",kwnames,&obj0,&obj1)) goto fail;
16690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16691 if (SWIG_arg_fail(1)) SWIG_fail;
16692 {
16693 arg2 = &temp2;
16694 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16695 }
16696 {
16697 PyThreadState* __tstate = wxPyBeginAllowThreads();
16698 (arg1)->SetTextBackground((wxColour const &)*arg2);
16699
16700 wxPyEndAllowThreads(__tstate);
16701 if (PyErr_Occurred()) SWIG_fail;
16702 }
16703 Py_INCREF(Py_None); resultobj = Py_None;
16704 return resultobj;
16705 fail:
16706 return NULL;
16707 }
16708
16709
16710 static PyObject *_wrap_DC_GetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16711 PyObject *resultobj;
16712 wxDC *arg1 = (wxDC *) 0 ;
16713 int result;
16714 PyObject * obj0 = 0 ;
16715 char *kwnames[] = {
16716 (char *) "self", NULL
16717 };
16718
16719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetMapMode",kwnames,&obj0)) goto fail;
16720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16721 if (SWIG_arg_fail(1)) SWIG_fail;
16722 {
16723 PyThreadState* __tstate = wxPyBeginAllowThreads();
16724 result = (int)((wxDC const *)arg1)->GetMapMode();
16725
16726 wxPyEndAllowThreads(__tstate);
16727 if (PyErr_Occurred()) SWIG_fail;
16728 }
16729 {
16730 resultobj = SWIG_From_int((int)(result));
16731 }
16732 return resultobj;
16733 fail:
16734 return NULL;
16735 }
16736
16737
16738 static PyObject *_wrap_DC_SetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16739 PyObject *resultobj;
16740 wxDC *arg1 = (wxDC *) 0 ;
16741 int arg2 ;
16742 PyObject * obj0 = 0 ;
16743 PyObject * obj1 = 0 ;
16744 char *kwnames[] = {
16745 (char *) "self",(char *) "mode", NULL
16746 };
16747
16748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetMapMode",kwnames,&obj0,&obj1)) goto fail;
16749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16750 if (SWIG_arg_fail(1)) SWIG_fail;
16751 {
16752 arg2 = (int)(SWIG_As_int(obj1));
16753 if (SWIG_arg_fail(2)) SWIG_fail;
16754 }
16755 {
16756 PyThreadState* __tstate = wxPyBeginAllowThreads();
16757 (arg1)->SetMapMode(arg2);
16758
16759 wxPyEndAllowThreads(__tstate);
16760 if (PyErr_Occurred()) SWIG_fail;
16761 }
16762 Py_INCREF(Py_None); resultobj = Py_None;
16763 return resultobj;
16764 fail:
16765 return NULL;
16766 }
16767
16768
16769 static PyObject *_wrap_DC_GetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16770 PyObject *resultobj;
16771 wxDC *arg1 = (wxDC *) 0 ;
16772 double *arg2 = (double *) 0 ;
16773 double *arg3 = (double *) 0 ;
16774 double temp2 ;
16775 int res2 = 0 ;
16776 double temp3 ;
16777 int res3 = 0 ;
16778 PyObject * obj0 = 0 ;
16779 char *kwnames[] = {
16780 (char *) "self", NULL
16781 };
16782
16783 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16784 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetUserScale",kwnames,&obj0)) goto fail;
16786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16787 if (SWIG_arg_fail(1)) SWIG_fail;
16788 {
16789 PyThreadState* __tstate = wxPyBeginAllowThreads();
16790 ((wxDC const *)arg1)->GetUserScale(arg2,arg3);
16791
16792 wxPyEndAllowThreads(__tstate);
16793 if (PyErr_Occurred()) SWIG_fail;
16794 }
16795 Py_INCREF(Py_None); resultobj = Py_None;
16796 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16797 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16798 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16799 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16800 return resultobj;
16801 fail:
16802 return NULL;
16803 }
16804
16805
16806 static PyObject *_wrap_DC_SetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16807 PyObject *resultobj;
16808 wxDC *arg1 = (wxDC *) 0 ;
16809 double arg2 ;
16810 double arg3 ;
16811 PyObject * obj0 = 0 ;
16812 PyObject * obj1 = 0 ;
16813 PyObject * obj2 = 0 ;
16814 char *kwnames[] = {
16815 (char *) "self",(char *) "x",(char *) "y", NULL
16816 };
16817
16818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetUserScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16820 if (SWIG_arg_fail(1)) SWIG_fail;
16821 {
16822 arg2 = (double)(SWIG_As_double(obj1));
16823 if (SWIG_arg_fail(2)) SWIG_fail;
16824 }
16825 {
16826 arg3 = (double)(SWIG_As_double(obj2));
16827 if (SWIG_arg_fail(3)) SWIG_fail;
16828 }
16829 {
16830 PyThreadState* __tstate = wxPyBeginAllowThreads();
16831 (arg1)->SetUserScale(arg2,arg3);
16832
16833 wxPyEndAllowThreads(__tstate);
16834 if (PyErr_Occurred()) SWIG_fail;
16835 }
16836 Py_INCREF(Py_None); resultobj = Py_None;
16837 return resultobj;
16838 fail:
16839 return NULL;
16840 }
16841
16842
16843 static PyObject *_wrap_DC_GetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16844 PyObject *resultobj;
16845 wxDC *arg1 = (wxDC *) 0 ;
16846 double *arg2 = (double *) 0 ;
16847 double *arg3 = (double *) 0 ;
16848 double temp2 ;
16849 int res2 = 0 ;
16850 double temp3 ;
16851 int res3 = 0 ;
16852 PyObject * obj0 = 0 ;
16853 char *kwnames[] = {
16854 (char *) "self", NULL
16855 };
16856
16857 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16858 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalScale",kwnames,&obj0)) goto fail;
16860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16861 if (SWIG_arg_fail(1)) SWIG_fail;
16862 {
16863 PyThreadState* __tstate = wxPyBeginAllowThreads();
16864 (arg1)->GetLogicalScale(arg2,arg3);
16865
16866 wxPyEndAllowThreads(__tstate);
16867 if (PyErr_Occurred()) SWIG_fail;
16868 }
16869 Py_INCREF(Py_None); resultobj = Py_None;
16870 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16871 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16872 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16873 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16874 return resultobj;
16875 fail:
16876 return NULL;
16877 }
16878
16879
16880 static PyObject *_wrap_DC_SetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16881 PyObject *resultobj;
16882 wxDC *arg1 = (wxDC *) 0 ;
16883 double arg2 ;
16884 double arg3 ;
16885 PyObject * obj0 = 0 ;
16886 PyObject * obj1 = 0 ;
16887 PyObject * obj2 = 0 ;
16888 char *kwnames[] = {
16889 (char *) "self",(char *) "x",(char *) "y", NULL
16890 };
16891
16892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16894 if (SWIG_arg_fail(1)) SWIG_fail;
16895 {
16896 arg2 = (double)(SWIG_As_double(obj1));
16897 if (SWIG_arg_fail(2)) SWIG_fail;
16898 }
16899 {
16900 arg3 = (double)(SWIG_As_double(obj2));
16901 if (SWIG_arg_fail(3)) SWIG_fail;
16902 }
16903 {
16904 PyThreadState* __tstate = wxPyBeginAllowThreads();
16905 (arg1)->SetLogicalScale(arg2,arg3);
16906
16907 wxPyEndAllowThreads(__tstate);
16908 if (PyErr_Occurred()) SWIG_fail;
16909 }
16910 Py_INCREF(Py_None); resultobj = Py_None;
16911 return resultobj;
16912 fail:
16913 return NULL;
16914 }
16915
16916
16917 static PyObject *_wrap_DC_GetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16918 PyObject *resultobj;
16919 wxDC *arg1 = (wxDC *) 0 ;
16920 wxPoint result;
16921 PyObject * obj0 = 0 ;
16922 char *kwnames[] = {
16923 (char *) "self", NULL
16924 };
16925
16926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOrigin",kwnames,&obj0)) goto fail;
16927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16928 if (SWIG_arg_fail(1)) SWIG_fail;
16929 {
16930 PyThreadState* __tstate = wxPyBeginAllowThreads();
16931 result = ((wxDC const *)arg1)->GetLogicalOrigin();
16932
16933 wxPyEndAllowThreads(__tstate);
16934 if (PyErr_Occurred()) SWIG_fail;
16935 }
16936 {
16937 wxPoint * resultptr;
16938 resultptr = new wxPoint((wxPoint &)(result));
16939 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16940 }
16941 return resultobj;
16942 fail:
16943 return NULL;
16944 }
16945
16946
16947 static PyObject *_wrap_DC_GetLogicalOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16948 PyObject *resultobj;
16949 wxDC *arg1 = (wxDC *) 0 ;
16950 int *arg2 = (int *) 0 ;
16951 int *arg3 = (int *) 0 ;
16952 int temp2 ;
16953 int res2 = 0 ;
16954 int temp3 ;
16955 int res3 = 0 ;
16956 PyObject * obj0 = 0 ;
16957 char *kwnames[] = {
16958 (char *) "self", NULL
16959 };
16960
16961 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16962 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOriginTuple",kwnames,&obj0)) goto fail;
16964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16965 if (SWIG_arg_fail(1)) SWIG_fail;
16966 {
16967 PyThreadState* __tstate = wxPyBeginAllowThreads();
16968 ((wxDC const *)arg1)->GetLogicalOrigin(arg2,arg3);
16969
16970 wxPyEndAllowThreads(__tstate);
16971 if (PyErr_Occurred()) SWIG_fail;
16972 }
16973 Py_INCREF(Py_None); resultobj = Py_None;
16974 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16975 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16976 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16977 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16978 return resultobj;
16979 fail:
16980 return NULL;
16981 }
16982
16983
16984 static PyObject *_wrap_DC_SetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16985 PyObject *resultobj;
16986 wxDC *arg1 = (wxDC *) 0 ;
16987 int arg2 ;
16988 int arg3 ;
16989 PyObject * obj0 = 0 ;
16990 PyObject * obj1 = 0 ;
16991 PyObject * obj2 = 0 ;
16992 char *kwnames[] = {
16993 (char *) "self",(char *) "x",(char *) "y", NULL
16994 };
16995
16996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
16997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16998 if (SWIG_arg_fail(1)) SWIG_fail;
16999 {
17000 arg2 = (int)(SWIG_As_int(obj1));
17001 if (SWIG_arg_fail(2)) SWIG_fail;
17002 }
17003 {
17004 arg3 = (int)(SWIG_As_int(obj2));
17005 if (SWIG_arg_fail(3)) SWIG_fail;
17006 }
17007 {
17008 PyThreadState* __tstate = wxPyBeginAllowThreads();
17009 (arg1)->SetLogicalOrigin(arg2,arg3);
17010
17011 wxPyEndAllowThreads(__tstate);
17012 if (PyErr_Occurred()) SWIG_fail;
17013 }
17014 Py_INCREF(Py_None); resultobj = Py_None;
17015 return resultobj;
17016 fail:
17017 return NULL;
17018 }
17019
17020
17021 static PyObject *_wrap_DC_SetLogicalOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
17022 PyObject *resultobj;
17023 wxDC *arg1 = (wxDC *) 0 ;
17024 wxPoint *arg2 = 0 ;
17025 wxPoint temp2 ;
17026 PyObject * obj0 = 0 ;
17027 PyObject * obj1 = 0 ;
17028 char *kwnames[] = {
17029 (char *) "self",(char *) "point", NULL
17030 };
17031
17032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalOriginPoint",kwnames,&obj0,&obj1)) goto fail;
17033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17034 if (SWIG_arg_fail(1)) SWIG_fail;
17035 {
17036 arg2 = &temp2;
17037 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17038 }
17039 {
17040 PyThreadState* __tstate = wxPyBeginAllowThreads();
17041 wxDC_SetLogicalOriginPoint(arg1,(wxPoint const &)*arg2);
17042
17043 wxPyEndAllowThreads(__tstate);
17044 if (PyErr_Occurred()) SWIG_fail;
17045 }
17046 Py_INCREF(Py_None); resultobj = Py_None;
17047 return resultobj;
17048 fail:
17049 return NULL;
17050 }
17051
17052
17053 static PyObject *_wrap_DC_GetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
17054 PyObject *resultobj;
17055 wxDC *arg1 = (wxDC *) 0 ;
17056 wxPoint result;
17057 PyObject * obj0 = 0 ;
17058 char *kwnames[] = {
17059 (char *) "self", NULL
17060 };
17061
17062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOrigin",kwnames,&obj0)) 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 {
17066 PyThreadState* __tstate = wxPyBeginAllowThreads();
17067 result = ((wxDC const *)arg1)->GetDeviceOrigin();
17068
17069 wxPyEndAllowThreads(__tstate);
17070 if (PyErr_Occurred()) SWIG_fail;
17071 }
17072 {
17073 wxPoint * resultptr;
17074 resultptr = new wxPoint((wxPoint &)(result));
17075 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17076 }
17077 return resultobj;
17078 fail:
17079 return NULL;
17080 }
17081
17082
17083 static PyObject *_wrap_DC_GetDeviceOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17084 PyObject *resultobj;
17085 wxDC *arg1 = (wxDC *) 0 ;
17086 int *arg2 = (int *) 0 ;
17087 int *arg3 = (int *) 0 ;
17088 int temp2 ;
17089 int res2 = 0 ;
17090 int temp3 ;
17091 int res3 = 0 ;
17092 PyObject * obj0 = 0 ;
17093 char *kwnames[] = {
17094 (char *) "self", NULL
17095 };
17096
17097 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17098 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOriginTuple",kwnames,&obj0)) goto fail;
17100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17101 if (SWIG_arg_fail(1)) SWIG_fail;
17102 {
17103 PyThreadState* __tstate = wxPyBeginAllowThreads();
17104 ((wxDC const *)arg1)->GetDeviceOrigin(arg2,arg3);
17105
17106 wxPyEndAllowThreads(__tstate);
17107 if (PyErr_Occurred()) SWIG_fail;
17108 }
17109 Py_INCREF(Py_None); resultobj = Py_None;
17110 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17111 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
17112 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17113 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
17114 return resultobj;
17115 fail:
17116 return NULL;
17117 }
17118
17119
17120 static PyObject *_wrap_DC_SetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
17121 PyObject *resultobj;
17122 wxDC *arg1 = (wxDC *) 0 ;
17123 int arg2 ;
17124 int arg3 ;
17125 PyObject * obj0 = 0 ;
17126 PyObject * obj1 = 0 ;
17127 PyObject * obj2 = 0 ;
17128 char *kwnames[] = {
17129 (char *) "self",(char *) "x",(char *) "y", NULL
17130 };
17131
17132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetDeviceOrigin",kwnames,&obj0,&obj1,&obj2)) 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 {
17136 arg2 = (int)(SWIG_As_int(obj1));
17137 if (SWIG_arg_fail(2)) SWIG_fail;
17138 }
17139 {
17140 arg3 = (int)(SWIG_As_int(obj2));
17141 if (SWIG_arg_fail(3)) SWIG_fail;
17142 }
17143 {
17144 PyThreadState* __tstate = wxPyBeginAllowThreads();
17145 (arg1)->SetDeviceOrigin(arg2,arg3);
17146
17147 wxPyEndAllowThreads(__tstate);
17148 if (PyErr_Occurred()) SWIG_fail;
17149 }
17150 Py_INCREF(Py_None); resultobj = Py_None;
17151 return resultobj;
17152 fail:
17153 return NULL;
17154 }
17155
17156
17157 static PyObject *_wrap_DC_SetDeviceOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
17158 PyObject *resultobj;
17159 wxDC *arg1 = (wxDC *) 0 ;
17160 wxPoint *arg2 = 0 ;
17161 wxPoint temp2 ;
17162 PyObject * obj0 = 0 ;
17163 PyObject * obj1 = 0 ;
17164 char *kwnames[] = {
17165 (char *) "self",(char *) "point", NULL
17166 };
17167
17168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetDeviceOriginPoint",kwnames,&obj0,&obj1)) goto fail;
17169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17170 if (SWIG_arg_fail(1)) SWIG_fail;
17171 {
17172 arg2 = &temp2;
17173 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17174 }
17175 {
17176 PyThreadState* __tstate = wxPyBeginAllowThreads();
17177 wxDC_SetDeviceOriginPoint(arg1,(wxPoint const &)*arg2);
17178
17179 wxPyEndAllowThreads(__tstate);
17180 if (PyErr_Occurred()) SWIG_fail;
17181 }
17182 Py_INCREF(Py_None); resultobj = Py_None;
17183 return resultobj;
17184 fail:
17185 return NULL;
17186 }
17187
17188
17189 static PyObject *_wrap_DC_SetAxisOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
17190 PyObject *resultobj;
17191 wxDC *arg1 = (wxDC *) 0 ;
17192 bool arg2 ;
17193 bool arg3 ;
17194 PyObject * obj0 = 0 ;
17195 PyObject * obj1 = 0 ;
17196 PyObject * obj2 = 0 ;
17197 char *kwnames[] = {
17198 (char *) "self",(char *) "xLeftRight",(char *) "yBottomUp", NULL
17199 };
17200
17201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetAxisOrientation",kwnames,&obj0,&obj1,&obj2)) goto fail;
17202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17203 if (SWIG_arg_fail(1)) SWIG_fail;
17204 {
17205 arg2 = (bool)(SWIG_As_bool(obj1));
17206 if (SWIG_arg_fail(2)) SWIG_fail;
17207 }
17208 {
17209 arg3 = (bool)(SWIG_As_bool(obj2));
17210 if (SWIG_arg_fail(3)) SWIG_fail;
17211 }
17212 {
17213 PyThreadState* __tstate = wxPyBeginAllowThreads();
17214 (arg1)->SetAxisOrientation(arg2,arg3);
17215
17216 wxPyEndAllowThreads(__tstate);
17217 if (PyErr_Occurred()) SWIG_fail;
17218 }
17219 Py_INCREF(Py_None); resultobj = Py_None;
17220 return resultobj;
17221 fail:
17222 return NULL;
17223 }
17224
17225
17226 static PyObject *_wrap_DC_GetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
17227 PyObject *resultobj;
17228 wxDC *arg1 = (wxDC *) 0 ;
17229 int result;
17230 PyObject * obj0 = 0 ;
17231 char *kwnames[] = {
17232 (char *) "self", NULL
17233 };
17234
17235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalFunction",kwnames,&obj0)) goto fail;
17236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17237 if (SWIG_arg_fail(1)) SWIG_fail;
17238 {
17239 PyThreadState* __tstate = wxPyBeginAllowThreads();
17240 result = (int)((wxDC const *)arg1)->GetLogicalFunction();
17241
17242 wxPyEndAllowThreads(__tstate);
17243 if (PyErr_Occurred()) SWIG_fail;
17244 }
17245 {
17246 resultobj = SWIG_From_int((int)(result));
17247 }
17248 return resultobj;
17249 fail:
17250 return NULL;
17251 }
17252
17253
17254 static PyObject *_wrap_DC_SetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
17255 PyObject *resultobj;
17256 wxDC *arg1 = (wxDC *) 0 ;
17257 int arg2 ;
17258 PyObject * obj0 = 0 ;
17259 PyObject * obj1 = 0 ;
17260 char *kwnames[] = {
17261 (char *) "self",(char *) "function", NULL
17262 };
17263
17264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalFunction",kwnames,&obj0,&obj1)) goto fail;
17265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17266 if (SWIG_arg_fail(1)) SWIG_fail;
17267 {
17268 arg2 = (int)(SWIG_As_int(obj1));
17269 if (SWIG_arg_fail(2)) SWIG_fail;
17270 }
17271 {
17272 PyThreadState* __tstate = wxPyBeginAllowThreads();
17273 (arg1)->SetLogicalFunction(arg2);
17274
17275 wxPyEndAllowThreads(__tstate);
17276 if (PyErr_Occurred()) SWIG_fail;
17277 }
17278 Py_INCREF(Py_None); resultobj = Py_None;
17279 return resultobj;
17280 fail:
17281 return NULL;
17282 }
17283
17284
17285 static PyObject *_wrap_DC_ComputeScaleAndOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
17286 PyObject *resultobj;
17287 wxDC *arg1 = (wxDC *) 0 ;
17288 PyObject * obj0 = 0 ;
17289 char *kwnames[] = {
17290 (char *) "self", NULL
17291 };
17292
17293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ComputeScaleAndOrigin",kwnames,&obj0)) goto fail;
17294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17295 if (SWIG_arg_fail(1)) SWIG_fail;
17296 {
17297 PyThreadState* __tstate = wxPyBeginAllowThreads();
17298 (arg1)->ComputeScaleAndOrigin();
17299
17300 wxPyEndAllowThreads(__tstate);
17301 if (PyErr_Occurred()) SWIG_fail;
17302 }
17303 Py_INCREF(Py_None); resultobj = Py_None;
17304 return resultobj;
17305 fail:
17306 return NULL;
17307 }
17308
17309
17310 static PyObject *_wrap_DC_CalcBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
17311 PyObject *resultobj;
17312 wxDC *arg1 = (wxDC *) 0 ;
17313 int arg2 ;
17314 int arg3 ;
17315 PyObject * obj0 = 0 ;
17316 PyObject * obj1 = 0 ;
17317 PyObject * obj2 = 0 ;
17318 char *kwnames[] = {
17319 (char *) "self",(char *) "x",(char *) "y", NULL
17320 };
17321
17322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CalcBoundingBox",kwnames,&obj0,&obj1,&obj2)) goto fail;
17323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17324 if (SWIG_arg_fail(1)) SWIG_fail;
17325 {
17326 arg2 = (int)(SWIG_As_int(obj1));
17327 if (SWIG_arg_fail(2)) SWIG_fail;
17328 }
17329 {
17330 arg3 = (int)(SWIG_As_int(obj2));
17331 if (SWIG_arg_fail(3)) SWIG_fail;
17332 }
17333 {
17334 PyThreadState* __tstate = wxPyBeginAllowThreads();
17335 (arg1)->CalcBoundingBox(arg2,arg3);
17336
17337 wxPyEndAllowThreads(__tstate);
17338 if (PyErr_Occurred()) SWIG_fail;
17339 }
17340 Py_INCREF(Py_None); resultobj = Py_None;
17341 return resultobj;
17342 fail:
17343 return NULL;
17344 }
17345
17346
17347 static PyObject *_wrap_DC_CalcBoundingBoxPoint(PyObject *, PyObject *args, PyObject *kwargs) {
17348 PyObject *resultobj;
17349 wxDC *arg1 = (wxDC *) 0 ;
17350 wxPoint *arg2 = 0 ;
17351 wxPoint temp2 ;
17352 PyObject * obj0 = 0 ;
17353 PyObject * obj1 = 0 ;
17354 char *kwnames[] = {
17355 (char *) "self",(char *) "point", NULL
17356 };
17357
17358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CalcBoundingBoxPoint",kwnames,&obj0,&obj1)) goto fail;
17359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17360 if (SWIG_arg_fail(1)) SWIG_fail;
17361 {
17362 arg2 = &temp2;
17363 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17364 }
17365 {
17366 PyThreadState* __tstate = wxPyBeginAllowThreads();
17367 wxDC_CalcBoundingBoxPoint(arg1,(wxPoint const &)*arg2);
17368
17369 wxPyEndAllowThreads(__tstate);
17370 if (PyErr_Occurred()) SWIG_fail;
17371 }
17372 Py_INCREF(Py_None); resultobj = Py_None;
17373 return resultobj;
17374 fail:
17375 return NULL;
17376 }
17377
17378
17379 static PyObject *_wrap_DC_ResetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
17380 PyObject *resultobj;
17381 wxDC *arg1 = (wxDC *) 0 ;
17382 PyObject * obj0 = 0 ;
17383 char *kwnames[] = {
17384 (char *) "self", NULL
17385 };
17386
17387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ResetBoundingBox",kwnames,&obj0)) goto fail;
17388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17389 if (SWIG_arg_fail(1)) SWIG_fail;
17390 {
17391 PyThreadState* __tstate = wxPyBeginAllowThreads();
17392 (arg1)->ResetBoundingBox();
17393
17394 wxPyEndAllowThreads(__tstate);
17395 if (PyErr_Occurred()) SWIG_fail;
17396 }
17397 Py_INCREF(Py_None); resultobj = Py_None;
17398 return resultobj;
17399 fail:
17400 return NULL;
17401 }
17402
17403
17404 static PyObject *_wrap_DC_MinX(PyObject *, PyObject *args, PyObject *kwargs) {
17405 PyObject *resultobj;
17406 wxDC *arg1 = (wxDC *) 0 ;
17407 int result;
17408 PyObject * obj0 = 0 ;
17409 char *kwnames[] = {
17410 (char *) "self", NULL
17411 };
17412
17413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinX",kwnames,&obj0)) goto fail;
17414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17415 if (SWIG_arg_fail(1)) SWIG_fail;
17416 {
17417 PyThreadState* __tstate = wxPyBeginAllowThreads();
17418 result = (int)((wxDC const *)arg1)->MinX();
17419
17420 wxPyEndAllowThreads(__tstate);
17421 if (PyErr_Occurred()) SWIG_fail;
17422 }
17423 {
17424 resultobj = SWIG_From_int((int)(result));
17425 }
17426 return resultobj;
17427 fail:
17428 return NULL;
17429 }
17430
17431
17432 static PyObject *_wrap_DC_MaxX(PyObject *, PyObject *args, PyObject *kwargs) {
17433 PyObject *resultobj;
17434 wxDC *arg1 = (wxDC *) 0 ;
17435 int result;
17436 PyObject * obj0 = 0 ;
17437 char *kwnames[] = {
17438 (char *) "self", NULL
17439 };
17440
17441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxX",kwnames,&obj0)) goto fail;
17442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17443 if (SWIG_arg_fail(1)) SWIG_fail;
17444 {
17445 PyThreadState* __tstate = wxPyBeginAllowThreads();
17446 result = (int)((wxDC const *)arg1)->MaxX();
17447
17448 wxPyEndAllowThreads(__tstate);
17449 if (PyErr_Occurred()) SWIG_fail;
17450 }
17451 {
17452 resultobj = SWIG_From_int((int)(result));
17453 }
17454 return resultobj;
17455 fail:
17456 return NULL;
17457 }
17458
17459
17460 static PyObject *_wrap_DC_MinY(PyObject *, PyObject *args, PyObject *kwargs) {
17461 PyObject *resultobj;
17462 wxDC *arg1 = (wxDC *) 0 ;
17463 int result;
17464 PyObject * obj0 = 0 ;
17465 char *kwnames[] = {
17466 (char *) "self", NULL
17467 };
17468
17469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinY",kwnames,&obj0)) goto fail;
17470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17471 if (SWIG_arg_fail(1)) SWIG_fail;
17472 {
17473 PyThreadState* __tstate = wxPyBeginAllowThreads();
17474 result = (int)((wxDC const *)arg1)->MinY();
17475
17476 wxPyEndAllowThreads(__tstate);
17477 if (PyErr_Occurred()) SWIG_fail;
17478 }
17479 {
17480 resultobj = SWIG_From_int((int)(result));
17481 }
17482 return resultobj;
17483 fail:
17484 return NULL;
17485 }
17486
17487
17488 static PyObject *_wrap_DC_MaxY(PyObject *, PyObject *args, PyObject *kwargs) {
17489 PyObject *resultobj;
17490 wxDC *arg1 = (wxDC *) 0 ;
17491 int result;
17492 PyObject * obj0 = 0 ;
17493 char *kwnames[] = {
17494 (char *) "self", NULL
17495 };
17496
17497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxY",kwnames,&obj0)) goto fail;
17498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17499 if (SWIG_arg_fail(1)) SWIG_fail;
17500 {
17501 PyThreadState* __tstate = wxPyBeginAllowThreads();
17502 result = (int)((wxDC const *)arg1)->MaxY();
17503
17504 wxPyEndAllowThreads(__tstate);
17505 if (PyErr_Occurred()) SWIG_fail;
17506 }
17507 {
17508 resultobj = SWIG_From_int((int)(result));
17509 }
17510 return resultobj;
17511 fail:
17512 return NULL;
17513 }
17514
17515
17516 static PyObject *_wrap_DC_GetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
17517 PyObject *resultobj;
17518 wxDC *arg1 = (wxDC *) 0 ;
17519 int *arg2 = (int *) 0 ;
17520 int *arg3 = (int *) 0 ;
17521 int *arg4 = (int *) 0 ;
17522 int *arg5 = (int *) 0 ;
17523 int temp2 ;
17524 int res2 = 0 ;
17525 int temp3 ;
17526 int res3 = 0 ;
17527 int temp4 ;
17528 int res4 = 0 ;
17529 int temp5 ;
17530 int res5 = 0 ;
17531 PyObject * obj0 = 0 ;
17532 char *kwnames[] = {
17533 (char *) "self", NULL
17534 };
17535
17536 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17537 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17538 arg4 = &temp4; res4 = SWIG_NEWOBJ;
17539 arg5 = &temp5; res5 = SWIG_NEWOBJ;
17540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBoundingBox",kwnames,&obj0)) goto fail;
17541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17542 if (SWIG_arg_fail(1)) SWIG_fail;
17543 {
17544 PyThreadState* __tstate = wxPyBeginAllowThreads();
17545 wxDC_GetBoundingBox(arg1,arg2,arg3,arg4,arg5);
17546
17547 wxPyEndAllowThreads(__tstate);
17548 if (PyErr_Occurred()) SWIG_fail;
17549 }
17550 Py_INCREF(Py_None); resultobj = Py_None;
17551 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17552 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
17553 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17554 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
17555 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
17556 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
17557 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
17558 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
17559 return resultobj;
17560 fail:
17561 return NULL;
17562 }
17563
17564
17565 static PyObject *_wrap_DC_GetHDC(PyObject *, PyObject *args, PyObject *kwargs) {
17566 PyObject *resultobj;
17567 wxDC *arg1 = (wxDC *) 0 ;
17568 long result;
17569 PyObject * obj0 = 0 ;
17570 char *kwnames[] = {
17571 (char *) "self", NULL
17572 };
17573
17574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetHDC",kwnames,&obj0)) goto fail;
17575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17576 if (SWIG_arg_fail(1)) SWIG_fail;
17577 {
17578 PyThreadState* __tstate = wxPyBeginAllowThreads();
17579 result = (long)(arg1)->GetHDC();
17580
17581 wxPyEndAllowThreads(__tstate);
17582 if (PyErr_Occurred()) SWIG_fail;
17583 }
17584 {
17585 resultobj = SWIG_From_long((long)(result));
17586 }
17587 return resultobj;
17588 fail:
17589 return NULL;
17590 }
17591
17592
17593 static PyObject *_wrap_DC__DrawPointList(PyObject *, PyObject *args, PyObject *kwargs) {
17594 PyObject *resultobj;
17595 wxDC *arg1 = (wxDC *) 0 ;
17596 PyObject *arg2 = (PyObject *) 0 ;
17597 PyObject *arg3 = (PyObject *) 0 ;
17598 PyObject *arg4 = (PyObject *) 0 ;
17599 PyObject *result;
17600 PyObject * obj0 = 0 ;
17601 PyObject * obj1 = 0 ;
17602 PyObject * obj2 = 0 ;
17603 PyObject * obj3 = 0 ;
17604 char *kwnames[] = {
17605 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17606 };
17607
17608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPointList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17610 if (SWIG_arg_fail(1)) SWIG_fail;
17611 arg2 = obj1;
17612 arg3 = obj2;
17613 arg4 = obj3;
17614 {
17615 PyThreadState* __tstate = wxPyBeginAllowThreads();
17616 result = (PyObject *)wxDC__DrawPointList(arg1,arg2,arg3,arg4);
17617
17618 wxPyEndAllowThreads(__tstate);
17619 if (PyErr_Occurred()) SWIG_fail;
17620 }
17621 resultobj = result;
17622 return resultobj;
17623 fail:
17624 return NULL;
17625 }
17626
17627
17628 static PyObject *_wrap_DC__DrawLineList(PyObject *, PyObject *args, PyObject *kwargs) {
17629 PyObject *resultobj;
17630 wxDC *arg1 = (wxDC *) 0 ;
17631 PyObject *arg2 = (PyObject *) 0 ;
17632 PyObject *arg3 = (PyObject *) 0 ;
17633 PyObject *arg4 = (PyObject *) 0 ;
17634 PyObject *result;
17635 PyObject * obj0 = 0 ;
17636 PyObject * obj1 = 0 ;
17637 PyObject * obj2 = 0 ;
17638 PyObject * obj3 = 0 ;
17639 char *kwnames[] = {
17640 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17641 };
17642
17643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawLineList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17645 if (SWIG_arg_fail(1)) SWIG_fail;
17646 arg2 = obj1;
17647 arg3 = obj2;
17648 arg4 = obj3;
17649 {
17650 PyThreadState* __tstate = wxPyBeginAllowThreads();
17651 result = (PyObject *)wxDC__DrawLineList(arg1,arg2,arg3,arg4);
17652
17653 wxPyEndAllowThreads(__tstate);
17654 if (PyErr_Occurred()) SWIG_fail;
17655 }
17656 resultobj = result;
17657 return resultobj;
17658 fail:
17659 return NULL;
17660 }
17661
17662
17663 static PyObject *_wrap_DC__DrawRectangleList(PyObject *, PyObject *args, PyObject *kwargs) {
17664 PyObject *resultobj;
17665 wxDC *arg1 = (wxDC *) 0 ;
17666 PyObject *arg2 = (PyObject *) 0 ;
17667 PyObject *arg3 = (PyObject *) 0 ;
17668 PyObject *arg4 = (PyObject *) 0 ;
17669 PyObject *result;
17670 PyObject * obj0 = 0 ;
17671 PyObject * obj1 = 0 ;
17672 PyObject * obj2 = 0 ;
17673 PyObject * obj3 = 0 ;
17674 char *kwnames[] = {
17675 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17676 };
17677
17678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawRectangleList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17680 if (SWIG_arg_fail(1)) SWIG_fail;
17681 arg2 = obj1;
17682 arg3 = obj2;
17683 arg4 = obj3;
17684 {
17685 PyThreadState* __tstate = wxPyBeginAllowThreads();
17686 result = (PyObject *)wxDC__DrawRectangleList(arg1,arg2,arg3,arg4);
17687
17688 wxPyEndAllowThreads(__tstate);
17689 if (PyErr_Occurred()) SWIG_fail;
17690 }
17691 resultobj = result;
17692 return resultobj;
17693 fail:
17694 return NULL;
17695 }
17696
17697
17698 static PyObject *_wrap_DC__DrawEllipseList(PyObject *, PyObject *args, PyObject *kwargs) {
17699 PyObject *resultobj;
17700 wxDC *arg1 = (wxDC *) 0 ;
17701 PyObject *arg2 = (PyObject *) 0 ;
17702 PyObject *arg3 = (PyObject *) 0 ;
17703 PyObject *arg4 = (PyObject *) 0 ;
17704 PyObject *result;
17705 PyObject * obj0 = 0 ;
17706 PyObject * obj1 = 0 ;
17707 PyObject * obj2 = 0 ;
17708 PyObject * obj3 = 0 ;
17709 char *kwnames[] = {
17710 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17711 };
17712
17713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawEllipseList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17715 if (SWIG_arg_fail(1)) SWIG_fail;
17716 arg2 = obj1;
17717 arg3 = obj2;
17718 arg4 = obj3;
17719 {
17720 PyThreadState* __tstate = wxPyBeginAllowThreads();
17721 result = (PyObject *)wxDC__DrawEllipseList(arg1,arg2,arg3,arg4);
17722
17723 wxPyEndAllowThreads(__tstate);
17724 if (PyErr_Occurred()) SWIG_fail;
17725 }
17726 resultobj = result;
17727 return resultobj;
17728 fail:
17729 return NULL;
17730 }
17731
17732
17733 static PyObject *_wrap_DC__DrawPolygonList(PyObject *, PyObject *args, PyObject *kwargs) {
17734 PyObject *resultobj;
17735 wxDC *arg1 = (wxDC *) 0 ;
17736 PyObject *arg2 = (PyObject *) 0 ;
17737 PyObject *arg3 = (PyObject *) 0 ;
17738 PyObject *arg4 = (PyObject *) 0 ;
17739 PyObject *result;
17740 PyObject * obj0 = 0 ;
17741 PyObject * obj1 = 0 ;
17742 PyObject * obj2 = 0 ;
17743 PyObject * obj3 = 0 ;
17744 char *kwnames[] = {
17745 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17746 };
17747
17748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPolygonList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17750 if (SWIG_arg_fail(1)) SWIG_fail;
17751 arg2 = obj1;
17752 arg3 = obj2;
17753 arg4 = obj3;
17754 {
17755 PyThreadState* __tstate = wxPyBeginAllowThreads();
17756 result = (PyObject *)wxDC__DrawPolygonList(arg1,arg2,arg3,arg4);
17757
17758 wxPyEndAllowThreads(__tstate);
17759 if (PyErr_Occurred()) SWIG_fail;
17760 }
17761 resultobj = result;
17762 return resultobj;
17763 fail:
17764 return NULL;
17765 }
17766
17767
17768 static PyObject *_wrap_DC__DrawTextList(PyObject *, PyObject *args, PyObject *kwargs) {
17769 PyObject *resultobj;
17770 wxDC *arg1 = (wxDC *) 0 ;
17771 PyObject *arg2 = (PyObject *) 0 ;
17772 PyObject *arg3 = (PyObject *) 0 ;
17773 PyObject *arg4 = (PyObject *) 0 ;
17774 PyObject *arg5 = (PyObject *) 0 ;
17775 PyObject *result;
17776 PyObject * obj0 = 0 ;
17777 PyObject * obj1 = 0 ;
17778 PyObject * obj2 = 0 ;
17779 PyObject * obj3 = 0 ;
17780 PyObject * obj4 = 0 ;
17781 char *kwnames[] = {
17782 (char *) "self",(char *) "textList",(char *) "pyPoints",(char *) "foregroundList",(char *) "backgroundList", NULL
17783 };
17784
17785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC__DrawTextList",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
17786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17787 if (SWIG_arg_fail(1)) SWIG_fail;
17788 arg2 = obj1;
17789 arg3 = obj2;
17790 arg4 = obj3;
17791 arg5 = obj4;
17792 {
17793 PyThreadState* __tstate = wxPyBeginAllowThreads();
17794 result = (PyObject *)wxDC__DrawTextList(arg1,arg2,arg3,arg4,arg5);
17795
17796 wxPyEndAllowThreads(__tstate);
17797 if (PyErr_Occurred()) SWIG_fail;
17798 }
17799 resultobj = result;
17800 return resultobj;
17801 fail:
17802 return NULL;
17803 }
17804
17805
17806 static PyObject * DC_swigregister(PyObject *, PyObject *args) {
17807 PyObject *obj;
17808 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17809 SWIG_TypeClientData(SWIGTYPE_p_wxDC, obj);
17810 Py_INCREF(obj);
17811 return Py_BuildValue((char *)"");
17812 }
17813 static PyObject *_wrap_new_MemoryDC(PyObject *, PyObject *args, PyObject *kwargs) {
17814 PyObject *resultobj;
17815 wxMemoryDC *result;
17816 char *kwnames[] = {
17817 NULL
17818 };
17819
17820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryDC",kwnames)) goto fail;
17821 {
17822 if (!wxPyCheckForApp()) SWIG_fail;
17823 PyThreadState* __tstate = wxPyBeginAllowThreads();
17824 result = (wxMemoryDC *)new wxMemoryDC();
17825
17826 wxPyEndAllowThreads(__tstate);
17827 if (PyErr_Occurred()) SWIG_fail;
17828 }
17829 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17830 return resultobj;
17831 fail:
17832 return NULL;
17833 }
17834
17835
17836 static PyObject *_wrap_new_MemoryDCFromDC(PyObject *, PyObject *args, PyObject *kwargs) {
17837 PyObject *resultobj;
17838 wxDC *arg1 = (wxDC *) 0 ;
17839 wxMemoryDC *result;
17840 PyObject * obj0 = 0 ;
17841 char *kwnames[] = {
17842 (char *) "oldDC", NULL
17843 };
17844
17845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_MemoryDCFromDC",kwnames,&obj0)) goto fail;
17846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17847 if (SWIG_arg_fail(1)) SWIG_fail;
17848 {
17849 if (!wxPyCheckForApp()) SWIG_fail;
17850 PyThreadState* __tstate = wxPyBeginAllowThreads();
17851 result = (wxMemoryDC *)new wxMemoryDC(arg1);
17852
17853 wxPyEndAllowThreads(__tstate);
17854 if (PyErr_Occurred()) SWIG_fail;
17855 }
17856 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17857 return resultobj;
17858 fail:
17859 return NULL;
17860 }
17861
17862
17863 static PyObject *_wrap_MemoryDC_SelectObject(PyObject *, PyObject *args, PyObject *kwargs) {
17864 PyObject *resultobj;
17865 wxMemoryDC *arg1 = (wxMemoryDC *) 0 ;
17866 wxBitmap *arg2 = 0 ;
17867 PyObject * obj0 = 0 ;
17868 PyObject * obj1 = 0 ;
17869 char *kwnames[] = {
17870 (char *) "self",(char *) "bitmap", NULL
17871 };
17872
17873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryDC_SelectObject",kwnames,&obj0,&obj1)) goto fail;
17874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_EXCEPTION | 0);
17875 if (SWIG_arg_fail(1)) SWIG_fail;
17876 {
17877 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17878 if (SWIG_arg_fail(2)) SWIG_fail;
17879 if (arg2 == NULL) {
17880 SWIG_null_ref("wxBitmap");
17881 }
17882 if (SWIG_arg_fail(2)) SWIG_fail;
17883 }
17884 {
17885 PyThreadState* __tstate = wxPyBeginAllowThreads();
17886 (arg1)->SelectObject((wxBitmap const &)*arg2);
17887
17888 wxPyEndAllowThreads(__tstate);
17889 if (PyErr_Occurred()) SWIG_fail;
17890 }
17891 Py_INCREF(Py_None); resultobj = Py_None;
17892 return resultobj;
17893 fail:
17894 return NULL;
17895 }
17896
17897
17898 static PyObject * MemoryDC_swigregister(PyObject *, PyObject *args) {
17899 PyObject *obj;
17900 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17901 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryDC, obj);
17902 Py_INCREF(obj);
17903 return Py_BuildValue((char *)"");
17904 }
17905 static PyObject *_wrap_new_BufferedDC__SWIG_0(PyObject *, PyObject *args) {
17906 PyObject *resultobj;
17907 wxDC *arg1 = (wxDC *) 0 ;
17908 wxBitmap const &arg2_defvalue = wxNullBitmap ;
17909 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
17910 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17911 wxBufferedDC *result;
17912 PyObject * obj0 = 0 ;
17913 PyObject * obj1 = 0 ;
17914 PyObject * obj2 = 0 ;
17915
17916 if(!PyArg_ParseTuple(args,(char *)"O|OO:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
17917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17918 if (SWIG_arg_fail(1)) SWIG_fail;
17919 if (obj1) {
17920 {
17921 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17922 if (SWIG_arg_fail(2)) SWIG_fail;
17923 if (arg2 == NULL) {
17924 SWIG_null_ref("wxBitmap");
17925 }
17926 if (SWIG_arg_fail(2)) SWIG_fail;
17927 }
17928 }
17929 if (obj2) {
17930 {
17931 arg3 = (int)(SWIG_As_int(obj2));
17932 if (SWIG_arg_fail(3)) SWIG_fail;
17933 }
17934 }
17935 {
17936 if (!wxPyCheckForApp()) SWIG_fail;
17937 PyThreadState* __tstate = wxPyBeginAllowThreads();
17938 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxBitmap const &)*arg2,arg3);
17939
17940 wxPyEndAllowThreads(__tstate);
17941 if (PyErr_Occurred()) SWIG_fail;
17942 }
17943 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17944 return resultobj;
17945 fail:
17946 return NULL;
17947 }
17948
17949
17950 static PyObject *_wrap_new_BufferedDC__SWIG_1(PyObject *, PyObject *args) {
17951 PyObject *resultobj;
17952 wxDC *arg1 = (wxDC *) 0 ;
17953 wxSize *arg2 = 0 ;
17954 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17955 wxBufferedDC *result;
17956 wxSize temp2 ;
17957 PyObject * obj0 = 0 ;
17958 PyObject * obj1 = 0 ;
17959 PyObject * obj2 = 0 ;
17960
17961 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
17962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17963 if (SWIG_arg_fail(1)) SWIG_fail;
17964 {
17965 arg2 = &temp2;
17966 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17967 }
17968 if (obj2) {
17969 {
17970 arg3 = (int)(SWIG_As_int(obj2));
17971 if (SWIG_arg_fail(3)) SWIG_fail;
17972 }
17973 }
17974 {
17975 if (!wxPyCheckForApp()) SWIG_fail;
17976 PyThreadState* __tstate = wxPyBeginAllowThreads();
17977 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxSize const &)*arg2,arg3);
17978
17979 wxPyEndAllowThreads(__tstate);
17980 if (PyErr_Occurred()) SWIG_fail;
17981 }
17982 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17983 return resultobj;
17984 fail:
17985 return NULL;
17986 }
17987
17988
17989 static PyObject *_wrap_new_BufferedDC(PyObject *self, PyObject *args) {
17990 int argc;
17991 PyObject *argv[4];
17992 int ii;
17993
17994 argc = PyObject_Length(args);
17995 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
17996 argv[ii] = PyTuple_GetItem(args,ii);
17997 }
17998 if ((argc >= 1) && (argc <= 3)) {
17999 int _v;
18000 {
18001 void *ptr;
18002 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
18003 _v = 0;
18004 PyErr_Clear();
18005 } else {
18006 _v = 1;
18007 }
18008 }
18009 if (_v) {
18010 if (argc <= 1) {
18011 return _wrap_new_BufferedDC__SWIG_0(self,args);
18012 }
18013 {
18014 void *ptr = 0;
18015 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxBitmap, 0) == -1) {
18016 _v = 0;
18017 PyErr_Clear();
18018 } else {
18019 _v = (ptr != 0);
18020 }
18021 }
18022 if (_v) {
18023 if (argc <= 2) {
18024 return _wrap_new_BufferedDC__SWIG_0(self,args);
18025 }
18026 _v = SWIG_Check_int(argv[2]);
18027 if (_v) {
18028 return _wrap_new_BufferedDC__SWIG_0(self,args);
18029 }
18030 }
18031 }
18032 }
18033 if ((argc >= 2) && (argc <= 3)) {
18034 int _v;
18035 {
18036 void *ptr;
18037 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
18038 _v = 0;
18039 PyErr_Clear();
18040 } else {
18041 _v = 1;
18042 }
18043 }
18044 if (_v) {
18045 {
18046 _v = wxPySimple_typecheck(argv[1], wxT("wxSize"), 2);
18047 }
18048 if (_v) {
18049 if (argc <= 2) {
18050 return _wrap_new_BufferedDC__SWIG_1(self,args);
18051 }
18052 _v = SWIG_Check_int(argv[2]);
18053 if (_v) {
18054 return _wrap_new_BufferedDC__SWIG_1(self,args);
18055 }
18056 }
18057 }
18058 }
18059
18060 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_BufferedDC'");
18061 return NULL;
18062 }
18063
18064
18065 static PyObject *_wrap_delete_BufferedDC(PyObject *, PyObject *args, PyObject *kwargs) {
18066 PyObject *resultobj;
18067 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
18068 PyObject * obj0 = 0 ;
18069 char *kwnames[] = {
18070 (char *) "self", NULL
18071 };
18072
18073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BufferedDC",kwnames,&obj0)) goto fail;
18074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, 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_BufferedDC_UnMask(PyObject *, PyObject *args, PyObject *kwargs) {
18091 PyObject *resultobj;
18092 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
18093 PyObject * obj0 = 0 ;
18094 char *kwnames[] = {
18095 (char *) "self", NULL
18096 };
18097
18098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BufferedDC_UnMask",kwnames,&obj0)) goto fail;
18099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
18100 if (SWIG_arg_fail(1)) SWIG_fail;
18101 {
18102 PyThreadState* __tstate = wxPyBeginAllowThreads();
18103 (arg1)->UnMask();
18104
18105 wxPyEndAllowThreads(__tstate);
18106 if (PyErr_Occurred()) SWIG_fail;
18107 }
18108 Py_INCREF(Py_None); resultobj = Py_None;
18109 return resultobj;
18110 fail:
18111 return NULL;
18112 }
18113
18114
18115 static PyObject * BufferedDC_swigregister(PyObject *, PyObject *args) {
18116 PyObject *obj;
18117 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18118 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedDC, obj);
18119 Py_INCREF(obj);
18120 return Py_BuildValue((char *)"");
18121 }
18122 static PyObject *_wrap_new_BufferedPaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
18123 PyObject *resultobj;
18124 wxWindow *arg1 = (wxWindow *) 0 ;
18125 wxBitmap const &arg2_defvalue = wxNullBitmap ;
18126 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
18127 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
18128 wxBufferedPaintDC *result;
18129 PyObject * obj0 = 0 ;
18130 PyObject * obj1 = 0 ;
18131 PyObject * obj2 = 0 ;
18132 char *kwnames[] = {
18133 (char *) "window",(char *) "buffer",(char *) "style", NULL
18134 };
18135
18136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_BufferedPaintDC",kwnames,&obj0,&obj1,&obj2)) goto fail;
18137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18138 if (SWIG_arg_fail(1)) SWIG_fail;
18139 if (obj1) {
18140 {
18141 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18142 if (SWIG_arg_fail(2)) SWIG_fail;
18143 if (arg2 == NULL) {
18144 SWIG_null_ref("wxBitmap");
18145 }
18146 if (SWIG_arg_fail(2)) SWIG_fail;
18147 }
18148 }
18149 if (obj2) {
18150 {
18151 arg3 = (int)(SWIG_As_int(obj2));
18152 if (SWIG_arg_fail(3)) SWIG_fail;
18153 }
18154 }
18155 {
18156 if (!wxPyCheckForApp()) SWIG_fail;
18157 PyThreadState* __tstate = wxPyBeginAllowThreads();
18158 result = (wxBufferedPaintDC *)new wxBufferedPaintDC(arg1,(wxBitmap const &)*arg2,arg3);
18159
18160 wxPyEndAllowThreads(__tstate);
18161 if (PyErr_Occurred()) SWIG_fail;
18162 }
18163 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedPaintDC, 1);
18164 return resultobj;
18165 fail:
18166 return NULL;
18167 }
18168
18169
18170 static PyObject * BufferedPaintDC_swigregister(PyObject *, PyObject *args) {
18171 PyObject *obj;
18172 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18173 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedPaintDC, obj);
18174 Py_INCREF(obj);
18175 return Py_BuildValue((char *)"");
18176 }
18177 static PyObject *_wrap_new_ScreenDC(PyObject *, PyObject *args, PyObject *kwargs) {
18178 PyObject *resultobj;
18179 wxScreenDC *result;
18180 char *kwnames[] = {
18181 NULL
18182 };
18183
18184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ScreenDC",kwnames)) goto fail;
18185 {
18186 if (!wxPyCheckForApp()) SWIG_fail;
18187 PyThreadState* __tstate = wxPyBeginAllowThreads();
18188 result = (wxScreenDC *)new wxScreenDC();
18189
18190 wxPyEndAllowThreads(__tstate);
18191 if (PyErr_Occurred()) SWIG_fail;
18192 }
18193 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScreenDC, 1);
18194 return resultobj;
18195 fail:
18196 return NULL;
18197 }
18198
18199
18200 static PyObject *_wrap_ScreenDC_StartDrawingOnTopWin(PyObject *, PyObject *args, PyObject *kwargs) {
18201 PyObject *resultobj;
18202 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
18203 wxWindow *arg2 = (wxWindow *) 0 ;
18204 bool result;
18205 PyObject * obj0 = 0 ;
18206 PyObject * obj1 = 0 ;
18207 char *kwnames[] = {
18208 (char *) "self",(char *) "window", NULL
18209 };
18210
18211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScreenDC_StartDrawingOnTopWin",kwnames,&obj0,&obj1)) goto fail;
18212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
18213 if (SWIG_arg_fail(1)) SWIG_fail;
18214 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18215 if (SWIG_arg_fail(2)) SWIG_fail;
18216 {
18217 PyThreadState* __tstate = wxPyBeginAllowThreads();
18218 result = (bool)(arg1)->StartDrawingOnTop(arg2);
18219
18220 wxPyEndAllowThreads(__tstate);
18221 if (PyErr_Occurred()) SWIG_fail;
18222 }
18223 {
18224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18225 }
18226 return resultobj;
18227 fail:
18228 return NULL;
18229 }
18230
18231
18232 static PyObject *_wrap_ScreenDC_StartDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
18233 PyObject *resultobj;
18234 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
18235 wxRect *arg2 = (wxRect *) NULL ;
18236 bool result;
18237 PyObject * obj0 = 0 ;
18238 PyObject * obj1 = 0 ;
18239 char *kwnames[] = {
18240 (char *) "self",(char *) "rect", NULL
18241 };
18242
18243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ScreenDC_StartDrawingOnTop",kwnames,&obj0,&obj1)) goto fail;
18244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
18245 if (SWIG_arg_fail(1)) SWIG_fail;
18246 if (obj1) {
18247 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
18248 if (SWIG_arg_fail(2)) SWIG_fail;
18249 }
18250 {
18251 PyThreadState* __tstate = wxPyBeginAllowThreads();
18252 result = (bool)(arg1)->StartDrawingOnTop(arg2);
18253
18254 wxPyEndAllowThreads(__tstate);
18255 if (PyErr_Occurred()) SWIG_fail;
18256 }
18257 {
18258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18259 }
18260 return resultobj;
18261 fail:
18262 return NULL;
18263 }
18264
18265
18266 static PyObject *_wrap_ScreenDC_EndDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
18267 PyObject *resultobj;
18268 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
18269 bool result;
18270 PyObject * obj0 = 0 ;
18271 char *kwnames[] = {
18272 (char *) "self", NULL
18273 };
18274
18275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScreenDC_EndDrawingOnTop",kwnames,&obj0)) goto fail;
18276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
18277 if (SWIG_arg_fail(1)) SWIG_fail;
18278 {
18279 PyThreadState* __tstate = wxPyBeginAllowThreads();
18280 result = (bool)(arg1)->EndDrawingOnTop();
18281
18282 wxPyEndAllowThreads(__tstate);
18283 if (PyErr_Occurred()) SWIG_fail;
18284 }
18285 {
18286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18287 }
18288 return resultobj;
18289 fail:
18290 return NULL;
18291 }
18292
18293
18294 static PyObject * ScreenDC_swigregister(PyObject *, PyObject *args) {
18295 PyObject *obj;
18296 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18297 SWIG_TypeClientData(SWIGTYPE_p_wxScreenDC, obj);
18298 Py_INCREF(obj);
18299 return Py_BuildValue((char *)"");
18300 }
18301 static PyObject *_wrap_new_ClientDC(PyObject *, PyObject *args, PyObject *kwargs) {
18302 PyObject *resultobj;
18303 wxWindow *arg1 = (wxWindow *) 0 ;
18304 wxClientDC *result;
18305 PyObject * obj0 = 0 ;
18306 char *kwnames[] = {
18307 (char *) "win", NULL
18308 };
18309
18310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ClientDC",kwnames,&obj0)) goto fail;
18311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18312 if (SWIG_arg_fail(1)) SWIG_fail;
18313 {
18314 if (!wxPyCheckForApp()) SWIG_fail;
18315 PyThreadState* __tstate = wxPyBeginAllowThreads();
18316 result = (wxClientDC *)new wxClientDC(arg1);
18317
18318 wxPyEndAllowThreads(__tstate);
18319 if (PyErr_Occurred()) SWIG_fail;
18320 }
18321 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClientDC, 1);
18322 return resultobj;
18323 fail:
18324 return NULL;
18325 }
18326
18327
18328 static PyObject * ClientDC_swigregister(PyObject *, PyObject *args) {
18329 PyObject *obj;
18330 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18331 SWIG_TypeClientData(SWIGTYPE_p_wxClientDC, obj);
18332 Py_INCREF(obj);
18333 return Py_BuildValue((char *)"");
18334 }
18335 static PyObject *_wrap_new_PaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
18336 PyObject *resultobj;
18337 wxWindow *arg1 = (wxWindow *) 0 ;
18338 wxPaintDC *result;
18339 PyObject * obj0 = 0 ;
18340 char *kwnames[] = {
18341 (char *) "win", NULL
18342 };
18343
18344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PaintDC",kwnames,&obj0)) goto fail;
18345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18346 if (SWIG_arg_fail(1)) SWIG_fail;
18347 {
18348 if (!wxPyCheckForApp()) SWIG_fail;
18349 PyThreadState* __tstate = wxPyBeginAllowThreads();
18350 result = (wxPaintDC *)new wxPaintDC(arg1);
18351
18352 wxPyEndAllowThreads(__tstate);
18353 if (PyErr_Occurred()) SWIG_fail;
18354 }
18355 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintDC, 1);
18356 return resultobj;
18357 fail:
18358 return NULL;
18359 }
18360
18361
18362 static PyObject * PaintDC_swigregister(PyObject *, PyObject *args) {
18363 PyObject *obj;
18364 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18365 SWIG_TypeClientData(SWIGTYPE_p_wxPaintDC, obj);
18366 Py_INCREF(obj);
18367 return Py_BuildValue((char *)"");
18368 }
18369 static PyObject *_wrap_new_WindowDC(PyObject *, PyObject *args, PyObject *kwargs) {
18370 PyObject *resultobj;
18371 wxWindow *arg1 = (wxWindow *) 0 ;
18372 wxWindowDC *result;
18373 PyObject * obj0 = 0 ;
18374 char *kwnames[] = {
18375 (char *) "win", NULL
18376 };
18377
18378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_WindowDC",kwnames,&obj0)) goto fail;
18379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18380 if (SWIG_arg_fail(1)) SWIG_fail;
18381 {
18382 if (!wxPyCheckForApp()) SWIG_fail;
18383 PyThreadState* __tstate = wxPyBeginAllowThreads();
18384 result = (wxWindowDC *)new wxWindowDC(arg1);
18385
18386 wxPyEndAllowThreads(__tstate);
18387 if (PyErr_Occurred()) SWIG_fail;
18388 }
18389 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDC, 1);
18390 return resultobj;
18391 fail:
18392 return NULL;
18393 }
18394
18395
18396 static PyObject * WindowDC_swigregister(PyObject *, PyObject *args) {
18397 PyObject *obj;
18398 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18399 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDC, obj);
18400 Py_INCREF(obj);
18401 return Py_BuildValue((char *)"");
18402 }
18403 static PyObject *_wrap_new_MirrorDC(PyObject *, PyObject *args, PyObject *kwargs) {
18404 PyObject *resultobj;
18405 wxDC *arg1 = 0 ;
18406 bool arg2 ;
18407 wxMirrorDC *result;
18408 PyObject * obj0 = 0 ;
18409 PyObject * obj1 = 0 ;
18410 char *kwnames[] = {
18411 (char *) "dc",(char *) "mirror", NULL
18412 };
18413
18414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_MirrorDC",kwnames,&obj0,&obj1)) goto fail;
18415 {
18416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18417 if (SWIG_arg_fail(1)) SWIG_fail;
18418 if (arg1 == NULL) {
18419 SWIG_null_ref("wxDC");
18420 }
18421 if (SWIG_arg_fail(1)) SWIG_fail;
18422 }
18423 {
18424 arg2 = (bool)(SWIG_As_bool(obj1));
18425 if (SWIG_arg_fail(2)) SWIG_fail;
18426 }
18427 {
18428 if (!wxPyCheckForApp()) SWIG_fail;
18429 PyThreadState* __tstate = wxPyBeginAllowThreads();
18430 result = (wxMirrorDC *)new wxMirrorDC(*arg1,arg2);
18431
18432 wxPyEndAllowThreads(__tstate);
18433 if (PyErr_Occurred()) SWIG_fail;
18434 }
18435 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMirrorDC, 1);
18436 return resultobj;
18437 fail:
18438 return NULL;
18439 }
18440
18441
18442 static PyObject * MirrorDC_swigregister(PyObject *, PyObject *args) {
18443 PyObject *obj;
18444 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18445 SWIG_TypeClientData(SWIGTYPE_p_wxMirrorDC, obj);
18446 Py_INCREF(obj);
18447 return Py_BuildValue((char *)"");
18448 }
18449 static PyObject *_wrap_new_PostScriptDC(PyObject *, PyObject *args, PyObject *kwargs) {
18450 PyObject *resultobj;
18451 wxPrintData *arg1 = 0 ;
18452 wxPostScriptDC *result;
18453 PyObject * obj0 = 0 ;
18454 char *kwnames[] = {
18455 (char *) "printData", NULL
18456 };
18457
18458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PostScriptDC",kwnames,&obj0)) goto fail;
18459 {
18460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18461 if (SWIG_arg_fail(1)) SWIG_fail;
18462 if (arg1 == NULL) {
18463 SWIG_null_ref("wxPrintData");
18464 }
18465 if (SWIG_arg_fail(1)) SWIG_fail;
18466 }
18467 {
18468 if (!wxPyCheckForApp()) SWIG_fail;
18469 PyThreadState* __tstate = wxPyBeginAllowThreads();
18470 result = (wxPostScriptDC *)new wxPostScriptDC((wxPrintData const &)*arg1);
18471
18472 wxPyEndAllowThreads(__tstate);
18473 if (PyErr_Occurred()) SWIG_fail;
18474 }
18475 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPostScriptDC, 1);
18476 return resultobj;
18477 fail:
18478 return NULL;
18479 }
18480
18481
18482 static PyObject *_wrap_PostScriptDC_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
18483 PyObject *resultobj;
18484 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
18485 wxPrintData *result;
18486 PyObject * obj0 = 0 ;
18487 char *kwnames[] = {
18488 (char *) "self", NULL
18489 };
18490
18491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_GetPrintData",kwnames,&obj0)) goto fail;
18492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
18493 if (SWIG_arg_fail(1)) SWIG_fail;
18494 {
18495 PyThreadState* __tstate = wxPyBeginAllowThreads();
18496 {
18497 wxPrintData &_result_ref = (arg1)->GetPrintData();
18498 result = (wxPrintData *) &_result_ref;
18499 }
18500
18501 wxPyEndAllowThreads(__tstate);
18502 if (PyErr_Occurred()) SWIG_fail;
18503 }
18504 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
18505 return resultobj;
18506 fail:
18507 return NULL;
18508 }
18509
18510
18511 static PyObject *_wrap_PostScriptDC_SetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
18512 PyObject *resultobj;
18513 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
18514 wxPrintData *arg2 = 0 ;
18515 PyObject * obj0 = 0 ;
18516 PyObject * obj1 = 0 ;
18517 char *kwnames[] = {
18518 (char *) "self",(char *) "data", NULL
18519 };
18520
18521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostScriptDC_SetPrintData",kwnames,&obj0,&obj1)) goto fail;
18522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
18523 if (SWIG_arg_fail(1)) SWIG_fail;
18524 {
18525 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18526 if (SWIG_arg_fail(2)) SWIG_fail;
18527 if (arg2 == NULL) {
18528 SWIG_null_ref("wxPrintData");
18529 }
18530 if (SWIG_arg_fail(2)) SWIG_fail;
18531 }
18532 {
18533 PyThreadState* __tstate = wxPyBeginAllowThreads();
18534 (arg1)->SetPrintData((wxPrintData const &)*arg2);
18535
18536 wxPyEndAllowThreads(__tstate);
18537 if (PyErr_Occurred()) SWIG_fail;
18538 }
18539 Py_INCREF(Py_None); resultobj = Py_None;
18540 return resultobj;
18541 fail:
18542 return NULL;
18543 }
18544
18545
18546 static PyObject *_wrap_PostScriptDC_SetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
18547 PyObject *resultobj;
18548 int arg1 ;
18549 PyObject * obj0 = 0 ;
18550 char *kwnames[] = {
18551 (char *) "ppi", NULL
18552 };
18553
18554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_SetResolution",kwnames,&obj0)) goto fail;
18555 {
18556 arg1 = (int)(SWIG_As_int(obj0));
18557 if (SWIG_arg_fail(1)) SWIG_fail;
18558 }
18559 {
18560 PyThreadState* __tstate = wxPyBeginAllowThreads();
18561 wxPostScriptDC::SetResolution(arg1);
18562
18563 wxPyEndAllowThreads(__tstate);
18564 if (PyErr_Occurred()) SWIG_fail;
18565 }
18566 Py_INCREF(Py_None); resultobj = Py_None;
18567 return resultobj;
18568 fail:
18569 return NULL;
18570 }
18571
18572
18573 static PyObject *_wrap_PostScriptDC_GetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
18574 PyObject *resultobj;
18575 int result;
18576 char *kwnames[] = {
18577 NULL
18578 };
18579
18580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PostScriptDC_GetResolution",kwnames)) goto fail;
18581 {
18582 PyThreadState* __tstate = wxPyBeginAllowThreads();
18583 result = (int)wxPostScriptDC::GetResolution();
18584
18585 wxPyEndAllowThreads(__tstate);
18586 if (PyErr_Occurred()) SWIG_fail;
18587 }
18588 {
18589 resultobj = SWIG_From_int((int)(result));
18590 }
18591 return resultobj;
18592 fail:
18593 return NULL;
18594 }
18595
18596
18597 static PyObject * PostScriptDC_swigregister(PyObject *, PyObject *args) {
18598 PyObject *obj;
18599 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18600 SWIG_TypeClientData(SWIGTYPE_p_wxPostScriptDC, obj);
18601 Py_INCREF(obj);
18602 return Py_BuildValue((char *)"");
18603 }
18604 static PyObject *_wrap_new_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
18605 PyObject *resultobj;
18606 wxString const &arg1_defvalue = wxPyEmptyString ;
18607 wxString *arg1 = (wxString *) &arg1_defvalue ;
18608 wxMetaFile *result;
18609 bool temp1 = false ;
18610 PyObject * obj0 = 0 ;
18611 char *kwnames[] = {
18612 (char *) "filename", NULL
18613 };
18614
18615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MetaFile",kwnames,&obj0)) goto fail;
18616 if (obj0) {
18617 {
18618 arg1 = wxString_in_helper(obj0);
18619 if (arg1 == NULL) SWIG_fail;
18620 temp1 = true;
18621 }
18622 }
18623 {
18624 if (!wxPyCheckForApp()) SWIG_fail;
18625 PyThreadState* __tstate = wxPyBeginAllowThreads();
18626 result = (wxMetaFile *)new wxMetaFile((wxString const &)*arg1);
18627
18628 wxPyEndAllowThreads(__tstate);
18629 if (PyErr_Occurred()) SWIG_fail;
18630 }
18631 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 1);
18632 {
18633 if (temp1)
18634 delete arg1;
18635 }
18636 return resultobj;
18637 fail:
18638 {
18639 if (temp1)
18640 delete arg1;
18641 }
18642 return NULL;
18643 }
18644
18645
18646 static PyObject *_wrap_delete_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
18647 PyObject *resultobj;
18648 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18649 PyObject * obj0 = 0 ;
18650 char *kwnames[] = {
18651 (char *) "self", NULL
18652 };
18653
18654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MetaFile",kwnames,&obj0)) goto fail;
18655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18656 if (SWIG_arg_fail(1)) SWIG_fail;
18657 {
18658 PyThreadState* __tstate = wxPyBeginAllowThreads();
18659 delete arg1;
18660
18661 wxPyEndAllowThreads(__tstate);
18662 if (PyErr_Occurred()) SWIG_fail;
18663 }
18664 Py_INCREF(Py_None); resultobj = Py_None;
18665 return resultobj;
18666 fail:
18667 return NULL;
18668 }
18669
18670
18671 static PyObject *_wrap_MetaFile_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
18672 PyObject *resultobj;
18673 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18674 bool result;
18675 PyObject * obj0 = 0 ;
18676 char *kwnames[] = {
18677 (char *) "self", NULL
18678 };
18679
18680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_Ok",kwnames,&obj0)) goto fail;
18681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18682 if (SWIG_arg_fail(1)) SWIG_fail;
18683 {
18684 PyThreadState* __tstate = wxPyBeginAllowThreads();
18685 result = (bool)(arg1)->Ok();
18686
18687 wxPyEndAllowThreads(__tstate);
18688 if (PyErr_Occurred()) SWIG_fail;
18689 }
18690 {
18691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18692 }
18693 return resultobj;
18694 fail:
18695 return NULL;
18696 }
18697
18698
18699 static PyObject *_wrap_MetaFile_SetClipboard(PyObject *, PyObject *args, PyObject *kwargs) {
18700 PyObject *resultobj;
18701 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18702 int arg2 = (int) 0 ;
18703 int arg3 = (int) 0 ;
18704 bool result;
18705 PyObject * obj0 = 0 ;
18706 PyObject * obj1 = 0 ;
18707 PyObject * obj2 = 0 ;
18708 char *kwnames[] = {
18709 (char *) "self",(char *) "width",(char *) "height", NULL
18710 };
18711
18712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MetaFile_SetClipboard",kwnames,&obj0,&obj1,&obj2)) goto fail;
18713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18714 if (SWIG_arg_fail(1)) SWIG_fail;
18715 if (obj1) {
18716 {
18717 arg2 = (int)(SWIG_As_int(obj1));
18718 if (SWIG_arg_fail(2)) SWIG_fail;
18719 }
18720 }
18721 if (obj2) {
18722 {
18723 arg3 = (int)(SWIG_As_int(obj2));
18724 if (SWIG_arg_fail(3)) SWIG_fail;
18725 }
18726 }
18727 {
18728 PyThreadState* __tstate = wxPyBeginAllowThreads();
18729 result = (bool)(arg1)->SetClipboard(arg2,arg3);
18730
18731 wxPyEndAllowThreads(__tstate);
18732 if (PyErr_Occurred()) SWIG_fail;
18733 }
18734 {
18735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18736 }
18737 return resultobj;
18738 fail:
18739 return NULL;
18740 }
18741
18742
18743 static PyObject *_wrap_MetaFile_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18744 PyObject *resultobj;
18745 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18746 wxSize result;
18747 PyObject * obj0 = 0 ;
18748 char *kwnames[] = {
18749 (char *) "self", NULL
18750 };
18751
18752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetSize",kwnames,&obj0)) goto fail;
18753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18754 if (SWIG_arg_fail(1)) SWIG_fail;
18755 {
18756 PyThreadState* __tstate = wxPyBeginAllowThreads();
18757 result = (arg1)->GetSize();
18758
18759 wxPyEndAllowThreads(__tstate);
18760 if (PyErr_Occurred()) SWIG_fail;
18761 }
18762 {
18763 wxSize * resultptr;
18764 resultptr = new wxSize((wxSize &)(result));
18765 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18766 }
18767 return resultobj;
18768 fail:
18769 return NULL;
18770 }
18771
18772
18773 static PyObject *_wrap_MetaFile_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
18774 PyObject *resultobj;
18775 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18776 int result;
18777 PyObject * obj0 = 0 ;
18778 char *kwnames[] = {
18779 (char *) "self", NULL
18780 };
18781
18782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetWidth",kwnames,&obj0)) goto fail;
18783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18784 if (SWIG_arg_fail(1)) SWIG_fail;
18785 {
18786 PyThreadState* __tstate = wxPyBeginAllowThreads();
18787 result = (int)(arg1)->GetWidth();
18788
18789 wxPyEndAllowThreads(__tstate);
18790 if (PyErr_Occurred()) SWIG_fail;
18791 }
18792 {
18793 resultobj = SWIG_From_int((int)(result));
18794 }
18795 return resultobj;
18796 fail:
18797 return NULL;
18798 }
18799
18800
18801 static PyObject *_wrap_MetaFile_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
18802 PyObject *resultobj;
18803 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18804 int result;
18805 PyObject * obj0 = 0 ;
18806 char *kwnames[] = {
18807 (char *) "self", NULL
18808 };
18809
18810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetHeight",kwnames,&obj0)) goto fail;
18811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18812 if (SWIG_arg_fail(1)) SWIG_fail;
18813 {
18814 PyThreadState* __tstate = wxPyBeginAllowThreads();
18815 result = (int)(arg1)->GetHeight();
18816
18817 wxPyEndAllowThreads(__tstate);
18818 if (PyErr_Occurred()) SWIG_fail;
18819 }
18820 {
18821 resultobj = SWIG_From_int((int)(result));
18822 }
18823 return resultobj;
18824 fail:
18825 return NULL;
18826 }
18827
18828
18829 static PyObject *_wrap_MetaFile_GetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
18830 PyObject *resultobj;
18831 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18832 wxString *result;
18833 PyObject * obj0 = 0 ;
18834 char *kwnames[] = {
18835 (char *) "self", NULL
18836 };
18837
18838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetFileName",kwnames,&obj0)) goto fail;
18839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18840 if (SWIG_arg_fail(1)) SWIG_fail;
18841 {
18842 PyThreadState* __tstate = wxPyBeginAllowThreads();
18843 {
18844 wxString const &_result_ref = ((wxMetaFile const *)arg1)->GetFileName();
18845 result = (wxString *) &_result_ref;
18846 }
18847
18848 wxPyEndAllowThreads(__tstate);
18849 if (PyErr_Occurred()) SWIG_fail;
18850 }
18851 {
18852 #if wxUSE_UNICODE
18853 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18854 #else
18855 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18856 #endif
18857 }
18858 return resultobj;
18859 fail:
18860 return NULL;
18861 }
18862
18863
18864 static PyObject * MetaFile_swigregister(PyObject *, PyObject *args) {
18865 PyObject *obj;
18866 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18867 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFile, obj);
18868 Py_INCREF(obj);
18869 return Py_BuildValue((char *)"");
18870 }
18871 static PyObject *_wrap_new_MetaFileDC(PyObject *, PyObject *args, PyObject *kwargs) {
18872 PyObject *resultobj;
18873 wxString const &arg1_defvalue = wxPyEmptyString ;
18874 wxString *arg1 = (wxString *) &arg1_defvalue ;
18875 int arg2 = (int) 0 ;
18876 int arg3 = (int) 0 ;
18877 wxString const &arg4_defvalue = wxPyEmptyString ;
18878 wxString *arg4 = (wxString *) &arg4_defvalue ;
18879 wxMetaFileDC *result;
18880 bool temp1 = false ;
18881 bool temp4 = false ;
18882 PyObject * obj0 = 0 ;
18883 PyObject * obj1 = 0 ;
18884 PyObject * obj2 = 0 ;
18885 PyObject * obj3 = 0 ;
18886 char *kwnames[] = {
18887 (char *) "filename",(char *) "width",(char *) "height",(char *) "description", NULL
18888 };
18889
18890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_MetaFileDC",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18891 if (obj0) {
18892 {
18893 arg1 = wxString_in_helper(obj0);
18894 if (arg1 == NULL) SWIG_fail;
18895 temp1 = true;
18896 }
18897 }
18898 if (obj1) {
18899 {
18900 arg2 = (int)(SWIG_As_int(obj1));
18901 if (SWIG_arg_fail(2)) SWIG_fail;
18902 }
18903 }
18904 if (obj2) {
18905 {
18906 arg3 = (int)(SWIG_As_int(obj2));
18907 if (SWIG_arg_fail(3)) SWIG_fail;
18908 }
18909 }
18910 if (obj3) {
18911 {
18912 arg4 = wxString_in_helper(obj3);
18913 if (arg4 == NULL) SWIG_fail;
18914 temp4 = true;
18915 }
18916 }
18917 {
18918 if (!wxPyCheckForApp()) SWIG_fail;
18919 PyThreadState* __tstate = wxPyBeginAllowThreads();
18920 result = (wxMetaFileDC *)new wxMetaFileDC((wxString const &)*arg1,arg2,arg3,(wxString const &)*arg4);
18921
18922 wxPyEndAllowThreads(__tstate);
18923 if (PyErr_Occurred()) SWIG_fail;
18924 }
18925 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFileDC, 1);
18926 {
18927 if (temp1)
18928 delete arg1;
18929 }
18930 {
18931 if (temp4)
18932 delete arg4;
18933 }
18934 return resultobj;
18935 fail:
18936 {
18937 if (temp1)
18938 delete arg1;
18939 }
18940 {
18941 if (temp4)
18942 delete arg4;
18943 }
18944 return NULL;
18945 }
18946
18947
18948 static PyObject *_wrap_MetaFileDC_Close(PyObject *, PyObject *args, PyObject *kwargs) {
18949 PyObject *resultobj;
18950 wxMetaFileDC *arg1 = (wxMetaFileDC *) 0 ;
18951 wxMetaFile *result;
18952 PyObject * obj0 = 0 ;
18953 char *kwnames[] = {
18954 (char *) "self", NULL
18955 };
18956
18957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFileDC_Close",kwnames,&obj0)) goto fail;
18958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFileDC, SWIG_POINTER_EXCEPTION | 0);
18959 if (SWIG_arg_fail(1)) SWIG_fail;
18960 {
18961 PyThreadState* __tstate = wxPyBeginAllowThreads();
18962 result = (wxMetaFile *)(arg1)->Close();
18963
18964 wxPyEndAllowThreads(__tstate);
18965 if (PyErr_Occurred()) SWIG_fail;
18966 }
18967 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 0);
18968 return resultobj;
18969 fail:
18970 return NULL;
18971 }
18972
18973
18974 static PyObject * MetaFileDC_swigregister(PyObject *, PyObject *args) {
18975 PyObject *obj;
18976 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18977 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFileDC, obj);
18978 Py_INCREF(obj);
18979 return Py_BuildValue((char *)"");
18980 }
18981 static PyObject *_wrap_new_PrinterDC(PyObject *, PyObject *args, PyObject *kwargs) {
18982 PyObject *resultobj;
18983 wxPrintData *arg1 = 0 ;
18984 wxPrinterDC *result;
18985 PyObject * obj0 = 0 ;
18986 char *kwnames[] = {
18987 (char *) "printData", NULL
18988 };
18989
18990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PrinterDC",kwnames,&obj0)) goto fail;
18991 {
18992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18993 if (SWIG_arg_fail(1)) SWIG_fail;
18994 if (arg1 == NULL) {
18995 SWIG_null_ref("wxPrintData");
18996 }
18997 if (SWIG_arg_fail(1)) SWIG_fail;
18998 }
18999 {
19000 if (!wxPyCheckForApp()) SWIG_fail;
19001 PyThreadState* __tstate = wxPyBeginAllowThreads();
19002 result = (wxPrinterDC *)new wxPrinterDC((wxPrintData const &)*arg1);
19003
19004 wxPyEndAllowThreads(__tstate);
19005 if (PyErr_Occurred()) SWIG_fail;
19006 }
19007 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrinterDC, 1);
19008 return resultobj;
19009 fail:
19010 return NULL;
19011 }
19012
19013
19014 static PyObject * PrinterDC_swigregister(PyObject *, PyObject *args) {
19015 PyObject *obj;
19016 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19017 SWIG_TypeClientData(SWIGTYPE_p_wxPrinterDC, obj);
19018 Py_INCREF(obj);
19019 return Py_BuildValue((char *)"");
19020 }
19021 static PyObject *_wrap_new_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
19022 PyObject *resultobj;
19023 int arg1 ;
19024 int arg2 ;
19025 int arg3 = (int) true ;
19026 int arg4 = (int) 1 ;
19027 wxImageList *result;
19028 PyObject * obj0 = 0 ;
19029 PyObject * obj1 = 0 ;
19030 PyObject * obj2 = 0 ;
19031 PyObject * obj3 = 0 ;
19032 char *kwnames[] = {
19033 (char *) "width",(char *) "height",(char *) "mask",(char *) "initialCount", NULL
19034 };
19035
19036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_ImageList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19037 {
19038 arg1 = (int)(SWIG_As_int(obj0));
19039 if (SWIG_arg_fail(1)) SWIG_fail;
19040 }
19041 {
19042 arg2 = (int)(SWIG_As_int(obj1));
19043 if (SWIG_arg_fail(2)) SWIG_fail;
19044 }
19045 if (obj2) {
19046 {
19047 arg3 = (int)(SWIG_As_int(obj2));
19048 if (SWIG_arg_fail(3)) SWIG_fail;
19049 }
19050 }
19051 if (obj3) {
19052 {
19053 arg4 = (int)(SWIG_As_int(obj3));
19054 if (SWIG_arg_fail(4)) SWIG_fail;
19055 }
19056 }
19057 {
19058 if (!wxPyCheckForApp()) SWIG_fail;
19059 PyThreadState* __tstate = wxPyBeginAllowThreads();
19060 result = (wxImageList *)new wxImageList(arg1,arg2,arg3,arg4);
19061
19062 wxPyEndAllowThreads(__tstate);
19063 if (PyErr_Occurred()) SWIG_fail;
19064 }
19065 {
19066 resultobj = wxPyMake_wxObject(result, 1);
19067 }
19068 return resultobj;
19069 fail:
19070 return NULL;
19071 }
19072
19073
19074 static PyObject *_wrap_delete_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
19075 PyObject *resultobj;
19076 wxImageList *arg1 = (wxImageList *) 0 ;
19077 PyObject * obj0 = 0 ;
19078 char *kwnames[] = {
19079 (char *) "self", NULL
19080 };
19081
19082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ImageList",kwnames,&obj0)) goto fail;
19083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19084 if (SWIG_arg_fail(1)) SWIG_fail;
19085 {
19086 PyThreadState* __tstate = wxPyBeginAllowThreads();
19087 delete arg1;
19088
19089 wxPyEndAllowThreads(__tstate);
19090 if (PyErr_Occurred()) SWIG_fail;
19091 }
19092 Py_INCREF(Py_None); resultobj = Py_None;
19093 return resultobj;
19094 fail:
19095 return NULL;
19096 }
19097
19098
19099 static PyObject *_wrap_ImageList_Add(PyObject *, PyObject *args, PyObject *kwargs) {
19100 PyObject *resultobj;
19101 wxImageList *arg1 = (wxImageList *) 0 ;
19102 wxBitmap *arg2 = 0 ;
19103 wxBitmap const &arg3_defvalue = wxNullBitmap ;
19104 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
19105 int result;
19106 PyObject * obj0 = 0 ;
19107 PyObject * obj1 = 0 ;
19108 PyObject * obj2 = 0 ;
19109 char *kwnames[] = {
19110 (char *) "self",(char *) "bitmap",(char *) "mask", NULL
19111 };
19112
19113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ImageList_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
19114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19115 if (SWIG_arg_fail(1)) SWIG_fail;
19116 {
19117 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19118 if (SWIG_arg_fail(2)) SWIG_fail;
19119 if (arg2 == NULL) {
19120 SWIG_null_ref("wxBitmap");
19121 }
19122 if (SWIG_arg_fail(2)) SWIG_fail;
19123 }
19124 if (obj2) {
19125 {
19126 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19127 if (SWIG_arg_fail(3)) SWIG_fail;
19128 if (arg3 == NULL) {
19129 SWIG_null_ref("wxBitmap");
19130 }
19131 if (SWIG_arg_fail(3)) SWIG_fail;
19132 }
19133 }
19134 {
19135 PyThreadState* __tstate = wxPyBeginAllowThreads();
19136 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
19137
19138 wxPyEndAllowThreads(__tstate);
19139 if (PyErr_Occurred()) SWIG_fail;
19140 }
19141 {
19142 resultobj = SWIG_From_int((int)(result));
19143 }
19144 return resultobj;
19145 fail:
19146 return NULL;
19147 }
19148
19149
19150 static PyObject *_wrap_ImageList_AddWithColourMask(PyObject *, PyObject *args, PyObject *kwargs) {
19151 PyObject *resultobj;
19152 wxImageList *arg1 = (wxImageList *) 0 ;
19153 wxBitmap *arg2 = 0 ;
19154 wxColour *arg3 = 0 ;
19155 int result;
19156 wxColour temp3 ;
19157 PyObject * obj0 = 0 ;
19158 PyObject * obj1 = 0 ;
19159 PyObject * obj2 = 0 ;
19160 char *kwnames[] = {
19161 (char *) "self",(char *) "bitmap",(char *) "maskColour", NULL
19162 };
19163
19164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_AddWithColourMask",kwnames,&obj0,&obj1,&obj2)) goto fail;
19165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19166 if (SWIG_arg_fail(1)) SWIG_fail;
19167 {
19168 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19169 if (SWIG_arg_fail(2)) SWIG_fail;
19170 if (arg2 == NULL) {
19171 SWIG_null_ref("wxBitmap");
19172 }
19173 if (SWIG_arg_fail(2)) SWIG_fail;
19174 }
19175 {
19176 arg3 = &temp3;
19177 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
19178 }
19179 {
19180 PyThreadState* __tstate = wxPyBeginAllowThreads();
19181 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxColour const &)*arg3);
19182
19183 wxPyEndAllowThreads(__tstate);
19184 if (PyErr_Occurred()) SWIG_fail;
19185 }
19186 {
19187 resultobj = SWIG_From_int((int)(result));
19188 }
19189 return resultobj;
19190 fail:
19191 return NULL;
19192 }
19193
19194
19195 static PyObject *_wrap_ImageList_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
19196 PyObject *resultobj;
19197 wxImageList *arg1 = (wxImageList *) 0 ;
19198 wxIcon *arg2 = 0 ;
19199 int result;
19200 PyObject * obj0 = 0 ;
19201 PyObject * obj1 = 0 ;
19202 char *kwnames[] = {
19203 (char *) "self",(char *) "icon", NULL
19204 };
19205
19206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_AddIcon",kwnames,&obj0,&obj1)) goto fail;
19207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19208 if (SWIG_arg_fail(1)) SWIG_fail;
19209 {
19210 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
19211 if (SWIG_arg_fail(2)) SWIG_fail;
19212 if (arg2 == NULL) {
19213 SWIG_null_ref("wxIcon");
19214 }
19215 if (SWIG_arg_fail(2)) SWIG_fail;
19216 }
19217 {
19218 PyThreadState* __tstate = wxPyBeginAllowThreads();
19219 result = (int)(arg1)->Add((wxIcon const &)*arg2);
19220
19221 wxPyEndAllowThreads(__tstate);
19222 if (PyErr_Occurred()) SWIG_fail;
19223 }
19224 {
19225 resultobj = SWIG_From_int((int)(result));
19226 }
19227 return resultobj;
19228 fail:
19229 return NULL;
19230 }
19231
19232
19233 static PyObject *_wrap_ImageList_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
19234 PyObject *resultobj;
19235 wxImageList *arg1 = (wxImageList *) 0 ;
19236 int arg2 ;
19237 SwigValueWrapper<wxBitmap > result;
19238 PyObject * obj0 = 0 ;
19239 PyObject * obj1 = 0 ;
19240 char *kwnames[] = {
19241 (char *) "self",(char *) "index", NULL
19242 };
19243
19244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetBitmap",kwnames,&obj0,&obj1)) goto fail;
19245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19246 if (SWIG_arg_fail(1)) SWIG_fail;
19247 {
19248 arg2 = (int)(SWIG_As_int(obj1));
19249 if (SWIG_arg_fail(2)) SWIG_fail;
19250 }
19251 {
19252 PyThreadState* __tstate = wxPyBeginAllowThreads();
19253 result = ((wxImageList const *)arg1)->GetBitmap(arg2);
19254
19255 wxPyEndAllowThreads(__tstate);
19256 if (PyErr_Occurred()) SWIG_fail;
19257 }
19258 {
19259 wxBitmap * resultptr;
19260 resultptr = new wxBitmap((wxBitmap &)(result));
19261 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
19262 }
19263 return resultobj;
19264 fail:
19265 return NULL;
19266 }
19267
19268
19269 static PyObject *_wrap_ImageList_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
19270 PyObject *resultobj;
19271 wxImageList *arg1 = (wxImageList *) 0 ;
19272 int arg2 ;
19273 wxIcon result;
19274 PyObject * obj0 = 0 ;
19275 PyObject * obj1 = 0 ;
19276 char *kwnames[] = {
19277 (char *) "self",(char *) "index", NULL
19278 };
19279
19280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetIcon",kwnames,&obj0,&obj1)) goto fail;
19281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19282 if (SWIG_arg_fail(1)) SWIG_fail;
19283 {
19284 arg2 = (int)(SWIG_As_int(obj1));
19285 if (SWIG_arg_fail(2)) SWIG_fail;
19286 }
19287 {
19288 PyThreadState* __tstate = wxPyBeginAllowThreads();
19289 result = ((wxImageList const *)arg1)->GetIcon(arg2);
19290
19291 wxPyEndAllowThreads(__tstate);
19292 if (PyErr_Occurred()) SWIG_fail;
19293 }
19294 {
19295 wxIcon * resultptr;
19296 resultptr = new wxIcon((wxIcon &)(result));
19297 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
19298 }
19299 return resultobj;
19300 fail:
19301 return NULL;
19302 }
19303
19304
19305 static PyObject *_wrap_ImageList_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
19306 PyObject *resultobj;
19307 wxImageList *arg1 = (wxImageList *) 0 ;
19308 int arg2 ;
19309 wxBitmap *arg3 = 0 ;
19310 wxBitmap const &arg4_defvalue = wxNullBitmap ;
19311 wxBitmap *arg4 = (wxBitmap *) &arg4_defvalue ;
19312 bool result;
19313 PyObject * obj0 = 0 ;
19314 PyObject * obj1 = 0 ;
19315 PyObject * obj2 = 0 ;
19316 PyObject * obj3 = 0 ;
19317 char *kwnames[] = {
19318 (char *) "self",(char *) "index",(char *) "bitmap",(char *) "mask", NULL
19319 };
19320
19321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ImageList_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19323 if (SWIG_arg_fail(1)) SWIG_fail;
19324 {
19325 arg2 = (int)(SWIG_As_int(obj1));
19326 if (SWIG_arg_fail(2)) SWIG_fail;
19327 }
19328 {
19329 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19330 if (SWIG_arg_fail(3)) SWIG_fail;
19331 if (arg3 == NULL) {
19332 SWIG_null_ref("wxBitmap");
19333 }
19334 if (SWIG_arg_fail(3)) SWIG_fail;
19335 }
19336 if (obj3) {
19337 {
19338 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19339 if (SWIG_arg_fail(4)) SWIG_fail;
19340 if (arg4 == NULL) {
19341 SWIG_null_ref("wxBitmap");
19342 }
19343 if (SWIG_arg_fail(4)) SWIG_fail;
19344 }
19345 }
19346 {
19347 PyThreadState* __tstate = wxPyBeginAllowThreads();
19348 result = (bool)(arg1)->Replace(arg2,(wxBitmap const &)*arg3,(wxBitmap const &)*arg4);
19349
19350 wxPyEndAllowThreads(__tstate);
19351 if (PyErr_Occurred()) SWIG_fail;
19352 }
19353 {
19354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19355 }
19356 return resultobj;
19357 fail:
19358 return NULL;
19359 }
19360
19361
19362 static PyObject *_wrap_ImageList_Draw(PyObject *, PyObject *args, PyObject *kwargs) {
19363 PyObject *resultobj;
19364 wxImageList *arg1 = (wxImageList *) 0 ;
19365 int arg2 ;
19366 wxDC *arg3 = 0 ;
19367 int arg4 ;
19368 int arg5 ;
19369 int arg6 = (int) wxIMAGELIST_DRAW_NORMAL ;
19370 bool arg7 = (bool) (bool)false ;
19371 bool result;
19372 PyObject * obj0 = 0 ;
19373 PyObject * obj1 = 0 ;
19374 PyObject * obj2 = 0 ;
19375 PyObject * obj3 = 0 ;
19376 PyObject * obj4 = 0 ;
19377 PyObject * obj5 = 0 ;
19378 PyObject * obj6 = 0 ;
19379 char *kwnames[] = {
19380 (char *) "self",(char *) "index",(char *) "dc",(char *) "x",(char *) "x",(char *) "flags",(char *) "solidBackground", NULL
19381 };
19382
19383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OO:ImageList_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19385 if (SWIG_arg_fail(1)) SWIG_fail;
19386 {
19387 arg2 = (int)(SWIG_As_int(obj1));
19388 if (SWIG_arg_fail(2)) SWIG_fail;
19389 }
19390 {
19391 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19392 if (SWIG_arg_fail(3)) SWIG_fail;
19393 if (arg3 == NULL) {
19394 SWIG_null_ref("wxDC");
19395 }
19396 if (SWIG_arg_fail(3)) SWIG_fail;
19397 }
19398 {
19399 arg4 = (int)(SWIG_As_int(obj3));
19400 if (SWIG_arg_fail(4)) SWIG_fail;
19401 }
19402 {
19403 arg5 = (int)(SWIG_As_int(obj4));
19404 if (SWIG_arg_fail(5)) SWIG_fail;
19405 }
19406 if (obj5) {
19407 {
19408 arg6 = (int)(SWIG_As_int(obj5));
19409 if (SWIG_arg_fail(6)) SWIG_fail;
19410 }
19411 }
19412 if (obj6) {
19413 {
19414 arg7 = (bool const)(SWIG_As_bool(obj6));
19415 if (SWIG_arg_fail(7)) SWIG_fail;
19416 }
19417 }
19418 {
19419 PyThreadState* __tstate = wxPyBeginAllowThreads();
19420 result = (bool)(arg1)->Draw(arg2,*arg3,arg4,arg5,arg6,arg7);
19421
19422 wxPyEndAllowThreads(__tstate);
19423 if (PyErr_Occurred()) SWIG_fail;
19424 }
19425 {
19426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19427 }
19428 return resultobj;
19429 fail:
19430 return NULL;
19431 }
19432
19433
19434 static PyObject *_wrap_ImageList_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
19435 PyObject *resultobj;
19436 wxImageList *arg1 = (wxImageList *) 0 ;
19437 int result;
19438 PyObject * obj0 = 0 ;
19439 char *kwnames[] = {
19440 (char *) "self", NULL
19441 };
19442
19443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_GetImageCount",kwnames,&obj0)) goto fail;
19444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19445 if (SWIG_arg_fail(1)) SWIG_fail;
19446 {
19447 PyThreadState* __tstate = wxPyBeginAllowThreads();
19448 result = (int)(arg1)->GetImageCount();
19449
19450 wxPyEndAllowThreads(__tstate);
19451 if (PyErr_Occurred()) SWIG_fail;
19452 }
19453 {
19454 resultobj = SWIG_From_int((int)(result));
19455 }
19456 return resultobj;
19457 fail:
19458 return NULL;
19459 }
19460
19461
19462 static PyObject *_wrap_ImageList_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
19463 PyObject *resultobj;
19464 wxImageList *arg1 = (wxImageList *) 0 ;
19465 int arg2 ;
19466 bool result;
19467 PyObject * obj0 = 0 ;
19468 PyObject * obj1 = 0 ;
19469 char *kwnames[] = {
19470 (char *) "self",(char *) "index", NULL
19471 };
19472
19473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_Remove",kwnames,&obj0,&obj1)) goto fail;
19474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19475 if (SWIG_arg_fail(1)) SWIG_fail;
19476 {
19477 arg2 = (int)(SWIG_As_int(obj1));
19478 if (SWIG_arg_fail(2)) SWIG_fail;
19479 }
19480 {
19481 PyThreadState* __tstate = wxPyBeginAllowThreads();
19482 result = (bool)(arg1)->Remove(arg2);
19483
19484 wxPyEndAllowThreads(__tstate);
19485 if (PyErr_Occurred()) SWIG_fail;
19486 }
19487 {
19488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19489 }
19490 return resultobj;
19491 fail:
19492 return NULL;
19493 }
19494
19495
19496 static PyObject *_wrap_ImageList_RemoveAll(PyObject *, PyObject *args, PyObject *kwargs) {
19497 PyObject *resultobj;
19498 wxImageList *arg1 = (wxImageList *) 0 ;
19499 bool result;
19500 PyObject * obj0 = 0 ;
19501 char *kwnames[] = {
19502 (char *) "self", NULL
19503 };
19504
19505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_RemoveAll",kwnames,&obj0)) goto fail;
19506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19507 if (SWIG_arg_fail(1)) SWIG_fail;
19508 {
19509 PyThreadState* __tstate = wxPyBeginAllowThreads();
19510 result = (bool)(arg1)->RemoveAll();
19511
19512 wxPyEndAllowThreads(__tstate);
19513 if (PyErr_Occurred()) SWIG_fail;
19514 }
19515 {
19516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19517 }
19518 return resultobj;
19519 fail:
19520 return NULL;
19521 }
19522
19523
19524 static PyObject *_wrap_ImageList_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19525 PyObject *resultobj;
19526 wxImageList *arg1 = (wxImageList *) 0 ;
19527 int arg2 ;
19528 int *arg3 = 0 ;
19529 int *arg4 = 0 ;
19530 int temp3 ;
19531 int res3 = 0 ;
19532 int temp4 ;
19533 int res4 = 0 ;
19534 PyObject * obj0 = 0 ;
19535 PyObject * obj1 = 0 ;
19536 char *kwnames[] = {
19537 (char *) "self",(char *) "index", NULL
19538 };
19539
19540 arg3 = &temp3; res3 = SWIG_NEWOBJ;
19541 arg4 = &temp4; res4 = SWIG_NEWOBJ;
19542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetSize",kwnames,&obj0,&obj1)) goto fail;
19543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19544 if (SWIG_arg_fail(1)) SWIG_fail;
19545 {
19546 arg2 = (int)(SWIG_As_int(obj1));
19547 if (SWIG_arg_fail(2)) SWIG_fail;
19548 }
19549 {
19550 PyThreadState* __tstate = wxPyBeginAllowThreads();
19551 (arg1)->GetSize(arg2,*arg3,*arg4);
19552
19553 wxPyEndAllowThreads(__tstate);
19554 if (PyErr_Occurred()) SWIG_fail;
19555 }
19556 Py_INCREF(Py_None); resultobj = Py_None;
19557 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19558 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
19559 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
19560 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
19561 return resultobj;
19562 fail:
19563 return NULL;
19564 }
19565
19566
19567 static PyObject * ImageList_swigregister(PyObject *, PyObject *args) {
19568 PyObject *obj;
19569 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19570 SWIG_TypeClientData(SWIGTYPE_p_wxImageList, obj);
19571 Py_INCREF(obj);
19572 return Py_BuildValue((char *)"");
19573 }
19574 static int _wrap_NORMAL_FONT_set(PyObject *) {
19575 PyErr_SetString(PyExc_TypeError,"Variable NORMAL_FONT is read-only.");
19576 return 1;
19577 }
19578
19579
19580 static PyObject *_wrap_NORMAL_FONT_get(void) {
19581 PyObject *pyobj;
19582
19583 pyobj = SWIG_NewPointerObj((void *)(wxNORMAL_FONT), SWIGTYPE_p_wxFont, 0);
19584 return pyobj;
19585 }
19586
19587
19588 static int _wrap_SMALL_FONT_set(PyObject *) {
19589 PyErr_SetString(PyExc_TypeError,"Variable SMALL_FONT is read-only.");
19590 return 1;
19591 }
19592
19593
19594 static PyObject *_wrap_SMALL_FONT_get(void) {
19595 PyObject *pyobj;
19596
19597 pyobj = SWIG_NewPointerObj((void *)(wxSMALL_FONT), SWIGTYPE_p_wxFont, 0);
19598 return pyobj;
19599 }
19600
19601
19602 static int _wrap_ITALIC_FONT_set(PyObject *) {
19603 PyErr_SetString(PyExc_TypeError,"Variable ITALIC_FONT is read-only.");
19604 return 1;
19605 }
19606
19607
19608 static PyObject *_wrap_ITALIC_FONT_get(void) {
19609 PyObject *pyobj;
19610
19611 pyobj = SWIG_NewPointerObj((void *)(wxITALIC_FONT), SWIGTYPE_p_wxFont, 0);
19612 return pyobj;
19613 }
19614
19615
19616 static int _wrap_SWISS_FONT_set(PyObject *) {
19617 PyErr_SetString(PyExc_TypeError,"Variable SWISS_FONT is read-only.");
19618 return 1;
19619 }
19620
19621
19622 static PyObject *_wrap_SWISS_FONT_get(void) {
19623 PyObject *pyobj;
19624
19625 pyobj = SWIG_NewPointerObj((void *)(wxSWISS_FONT), SWIGTYPE_p_wxFont, 0);
19626 return pyobj;
19627 }
19628
19629
19630 static int _wrap_RED_PEN_set(PyObject *) {
19631 PyErr_SetString(PyExc_TypeError,"Variable RED_PEN is read-only.");
19632 return 1;
19633 }
19634
19635
19636 static PyObject *_wrap_RED_PEN_get(void) {
19637 PyObject *pyobj;
19638
19639 pyobj = SWIG_NewPointerObj((void *)(wxRED_PEN), SWIGTYPE_p_wxPen, 0);
19640 return pyobj;
19641 }
19642
19643
19644 static int _wrap_CYAN_PEN_set(PyObject *) {
19645 PyErr_SetString(PyExc_TypeError,"Variable CYAN_PEN is read-only.");
19646 return 1;
19647 }
19648
19649
19650 static PyObject *_wrap_CYAN_PEN_get(void) {
19651 PyObject *pyobj;
19652
19653 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_PEN), SWIGTYPE_p_wxPen, 0);
19654 return pyobj;
19655 }
19656
19657
19658 static int _wrap_GREEN_PEN_set(PyObject *) {
19659 PyErr_SetString(PyExc_TypeError,"Variable GREEN_PEN is read-only.");
19660 return 1;
19661 }
19662
19663
19664 static PyObject *_wrap_GREEN_PEN_get(void) {
19665 PyObject *pyobj;
19666
19667 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_PEN), SWIGTYPE_p_wxPen, 0);
19668 return pyobj;
19669 }
19670
19671
19672 static int _wrap_BLACK_PEN_set(PyObject *) {
19673 PyErr_SetString(PyExc_TypeError,"Variable BLACK_PEN is read-only.");
19674 return 1;
19675 }
19676
19677
19678 static PyObject *_wrap_BLACK_PEN_get(void) {
19679 PyObject *pyobj;
19680
19681 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_PEN), SWIGTYPE_p_wxPen, 0);
19682 return pyobj;
19683 }
19684
19685
19686 static int _wrap_WHITE_PEN_set(PyObject *) {
19687 PyErr_SetString(PyExc_TypeError,"Variable WHITE_PEN is read-only.");
19688 return 1;
19689 }
19690
19691
19692 static PyObject *_wrap_WHITE_PEN_get(void) {
19693 PyObject *pyobj;
19694
19695 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_PEN), SWIGTYPE_p_wxPen, 0);
19696 return pyobj;
19697 }
19698
19699
19700 static int _wrap_TRANSPARENT_PEN_set(PyObject *) {
19701 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_PEN is read-only.");
19702 return 1;
19703 }
19704
19705
19706 static PyObject *_wrap_TRANSPARENT_PEN_get(void) {
19707 PyObject *pyobj;
19708
19709 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_PEN), SWIGTYPE_p_wxPen, 0);
19710 return pyobj;
19711 }
19712
19713
19714 static int _wrap_BLACK_DASHED_PEN_set(PyObject *) {
19715 PyErr_SetString(PyExc_TypeError,"Variable BLACK_DASHED_PEN is read-only.");
19716 return 1;
19717 }
19718
19719
19720 static PyObject *_wrap_BLACK_DASHED_PEN_get(void) {
19721 PyObject *pyobj;
19722
19723 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_DASHED_PEN), SWIGTYPE_p_wxPen, 0);
19724 return pyobj;
19725 }
19726
19727
19728 static int _wrap_GREY_PEN_set(PyObject *) {
19729 PyErr_SetString(PyExc_TypeError,"Variable GREY_PEN is read-only.");
19730 return 1;
19731 }
19732
19733
19734 static PyObject *_wrap_GREY_PEN_get(void) {
19735 PyObject *pyobj;
19736
19737 pyobj = SWIG_NewPointerObj((void *)(wxGREY_PEN), SWIGTYPE_p_wxPen, 0);
19738 return pyobj;
19739 }
19740
19741
19742 static int _wrap_MEDIUM_GREY_PEN_set(PyObject *) {
19743 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_PEN is read-only.");
19744 return 1;
19745 }
19746
19747
19748 static PyObject *_wrap_MEDIUM_GREY_PEN_get(void) {
19749 PyObject *pyobj;
19750
19751 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_PEN), SWIGTYPE_p_wxPen, 0);
19752 return pyobj;
19753 }
19754
19755
19756 static int _wrap_LIGHT_GREY_PEN_set(PyObject *) {
19757 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_PEN is read-only.");
19758 return 1;
19759 }
19760
19761
19762 static PyObject *_wrap_LIGHT_GREY_PEN_get(void) {
19763 PyObject *pyobj;
19764
19765 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_PEN), SWIGTYPE_p_wxPen, 0);
19766 return pyobj;
19767 }
19768
19769
19770 static int _wrap_BLUE_BRUSH_set(PyObject *) {
19771 PyErr_SetString(PyExc_TypeError,"Variable BLUE_BRUSH is read-only.");
19772 return 1;
19773 }
19774
19775
19776 static PyObject *_wrap_BLUE_BRUSH_get(void) {
19777 PyObject *pyobj;
19778
19779 pyobj = SWIG_NewPointerObj((void *)(wxBLUE_BRUSH), SWIGTYPE_p_wxBrush, 0);
19780 return pyobj;
19781 }
19782
19783
19784 static int _wrap_GREEN_BRUSH_set(PyObject *) {
19785 PyErr_SetString(PyExc_TypeError,"Variable GREEN_BRUSH is read-only.");
19786 return 1;
19787 }
19788
19789
19790 static PyObject *_wrap_GREEN_BRUSH_get(void) {
19791 PyObject *pyobj;
19792
19793 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_BRUSH), SWIGTYPE_p_wxBrush, 0);
19794 return pyobj;
19795 }
19796
19797
19798 static int _wrap_WHITE_BRUSH_set(PyObject *) {
19799 PyErr_SetString(PyExc_TypeError,"Variable WHITE_BRUSH is read-only.");
19800 return 1;
19801 }
19802
19803
19804 static PyObject *_wrap_WHITE_BRUSH_get(void) {
19805 PyObject *pyobj;
19806
19807 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_BRUSH), SWIGTYPE_p_wxBrush, 0);
19808 return pyobj;
19809 }
19810
19811
19812 static int _wrap_BLACK_BRUSH_set(PyObject *) {
19813 PyErr_SetString(PyExc_TypeError,"Variable BLACK_BRUSH is read-only.");
19814 return 1;
19815 }
19816
19817
19818 static PyObject *_wrap_BLACK_BRUSH_get(void) {
19819 PyObject *pyobj;
19820
19821 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_BRUSH), SWIGTYPE_p_wxBrush, 0);
19822 return pyobj;
19823 }
19824
19825
19826 static int _wrap_TRANSPARENT_BRUSH_set(PyObject *) {
19827 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_BRUSH is read-only.");
19828 return 1;
19829 }
19830
19831
19832 static PyObject *_wrap_TRANSPARENT_BRUSH_get(void) {
19833 PyObject *pyobj;
19834
19835 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_BRUSH), SWIGTYPE_p_wxBrush, 0);
19836 return pyobj;
19837 }
19838
19839
19840 static int _wrap_CYAN_BRUSH_set(PyObject *) {
19841 PyErr_SetString(PyExc_TypeError,"Variable CYAN_BRUSH is read-only.");
19842 return 1;
19843 }
19844
19845
19846 static PyObject *_wrap_CYAN_BRUSH_get(void) {
19847 PyObject *pyobj;
19848
19849 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_BRUSH), SWIGTYPE_p_wxBrush, 0);
19850 return pyobj;
19851 }
19852
19853
19854 static int _wrap_RED_BRUSH_set(PyObject *) {
19855 PyErr_SetString(PyExc_TypeError,"Variable RED_BRUSH is read-only.");
19856 return 1;
19857 }
19858
19859
19860 static PyObject *_wrap_RED_BRUSH_get(void) {
19861 PyObject *pyobj;
19862
19863 pyobj = SWIG_NewPointerObj((void *)(wxRED_BRUSH), SWIGTYPE_p_wxBrush, 0);
19864 return pyobj;
19865 }
19866
19867
19868 static int _wrap_GREY_BRUSH_set(PyObject *) {
19869 PyErr_SetString(PyExc_TypeError,"Variable GREY_BRUSH is read-only.");
19870 return 1;
19871 }
19872
19873
19874 static PyObject *_wrap_GREY_BRUSH_get(void) {
19875 PyObject *pyobj;
19876
19877 pyobj = SWIG_NewPointerObj((void *)(wxGREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19878 return pyobj;
19879 }
19880
19881
19882 static int _wrap_MEDIUM_GREY_BRUSH_set(PyObject *) {
19883 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_BRUSH is read-only.");
19884 return 1;
19885 }
19886
19887
19888 static PyObject *_wrap_MEDIUM_GREY_BRUSH_get(void) {
19889 PyObject *pyobj;
19890
19891 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19892 return pyobj;
19893 }
19894
19895
19896 static int _wrap_LIGHT_GREY_BRUSH_set(PyObject *) {
19897 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_BRUSH is read-only.");
19898 return 1;
19899 }
19900
19901
19902 static PyObject *_wrap_LIGHT_GREY_BRUSH_get(void) {
19903 PyObject *pyobj;
19904
19905 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19906 return pyobj;
19907 }
19908
19909
19910 static int _wrap_BLACK_set(PyObject *) {
19911 PyErr_SetString(PyExc_TypeError,"Variable BLACK is read-only.");
19912 return 1;
19913 }
19914
19915
19916 static PyObject *_wrap_BLACK_get(void) {
19917 PyObject *pyobj;
19918
19919 pyobj = SWIG_NewPointerObj((void *)(wxBLACK), SWIGTYPE_p_wxColour, 0);
19920 return pyobj;
19921 }
19922
19923
19924 static int _wrap_WHITE_set(PyObject *) {
19925 PyErr_SetString(PyExc_TypeError,"Variable WHITE is read-only.");
19926 return 1;
19927 }
19928
19929
19930 static PyObject *_wrap_WHITE_get(void) {
19931 PyObject *pyobj;
19932
19933 pyobj = SWIG_NewPointerObj((void *)(wxWHITE), SWIGTYPE_p_wxColour, 0);
19934 return pyobj;
19935 }
19936
19937
19938 static int _wrap_RED_set(PyObject *) {
19939 PyErr_SetString(PyExc_TypeError,"Variable RED is read-only.");
19940 return 1;
19941 }
19942
19943
19944 static PyObject *_wrap_RED_get(void) {
19945 PyObject *pyobj;
19946
19947 pyobj = SWIG_NewPointerObj((void *)(wxRED), SWIGTYPE_p_wxColour, 0);
19948 return pyobj;
19949 }
19950
19951
19952 static int _wrap_BLUE_set(PyObject *) {
19953 PyErr_SetString(PyExc_TypeError,"Variable BLUE is read-only.");
19954 return 1;
19955 }
19956
19957
19958 static PyObject *_wrap_BLUE_get(void) {
19959 PyObject *pyobj;
19960
19961 pyobj = SWIG_NewPointerObj((void *)(wxBLUE), SWIGTYPE_p_wxColour, 0);
19962 return pyobj;
19963 }
19964
19965
19966 static int _wrap_GREEN_set(PyObject *) {
19967 PyErr_SetString(PyExc_TypeError,"Variable GREEN is read-only.");
19968 return 1;
19969 }
19970
19971
19972 static PyObject *_wrap_GREEN_get(void) {
19973 PyObject *pyobj;
19974
19975 pyobj = SWIG_NewPointerObj((void *)(wxGREEN), SWIGTYPE_p_wxColour, 0);
19976 return pyobj;
19977 }
19978
19979
19980 static int _wrap_CYAN_set(PyObject *) {
19981 PyErr_SetString(PyExc_TypeError,"Variable CYAN is read-only.");
19982 return 1;
19983 }
19984
19985
19986 static PyObject *_wrap_CYAN_get(void) {
19987 PyObject *pyobj;
19988
19989 pyobj = SWIG_NewPointerObj((void *)(wxCYAN), SWIGTYPE_p_wxColour, 0);
19990 return pyobj;
19991 }
19992
19993
19994 static int _wrap_LIGHT_GREY_set(PyObject *) {
19995 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY is read-only.");
19996 return 1;
19997 }
19998
19999
20000 static PyObject *_wrap_LIGHT_GREY_get(void) {
20001 PyObject *pyobj;
20002
20003 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY), SWIGTYPE_p_wxColour, 0);
20004 return pyobj;
20005 }
20006
20007
20008 static int _wrap_STANDARD_CURSOR_set(PyObject *) {
20009 PyErr_SetString(PyExc_TypeError,"Variable STANDARD_CURSOR is read-only.");
20010 return 1;
20011 }
20012
20013
20014 static PyObject *_wrap_STANDARD_CURSOR_get(void) {
20015 PyObject *pyobj;
20016
20017 pyobj = SWIG_NewPointerObj((void *)(wxSTANDARD_CURSOR), SWIGTYPE_p_wxCursor, 0);
20018 return pyobj;
20019 }
20020
20021
20022 static int _wrap_HOURGLASS_CURSOR_set(PyObject *) {
20023 PyErr_SetString(PyExc_TypeError,"Variable HOURGLASS_CURSOR is read-only.");
20024 return 1;
20025 }
20026
20027
20028 static PyObject *_wrap_HOURGLASS_CURSOR_get(void) {
20029 PyObject *pyobj;
20030
20031 pyobj = SWIG_NewPointerObj((void *)(wxHOURGLASS_CURSOR), SWIGTYPE_p_wxCursor, 0);
20032 return pyobj;
20033 }
20034
20035
20036 static int _wrap_CROSS_CURSOR_set(PyObject *) {
20037 PyErr_SetString(PyExc_TypeError,"Variable CROSS_CURSOR is read-only.");
20038 return 1;
20039 }
20040
20041
20042 static PyObject *_wrap_CROSS_CURSOR_get(void) {
20043 PyObject *pyobj;
20044
20045 pyobj = SWIG_NewPointerObj((void *)(wxCROSS_CURSOR), SWIGTYPE_p_wxCursor, 0);
20046 return pyobj;
20047 }
20048
20049
20050 static int _wrap_NullBitmap_set(PyObject *) {
20051 PyErr_SetString(PyExc_TypeError,"Variable NullBitmap is read-only.");
20052 return 1;
20053 }
20054
20055
20056 static PyObject *_wrap_NullBitmap_get(void) {
20057 PyObject *pyobj;
20058
20059 pyobj = SWIG_NewPointerObj((void *)(&wxNullBitmap), SWIGTYPE_p_wxBitmap, 0);
20060 return pyobj;
20061 }
20062
20063
20064 static int _wrap_NullIcon_set(PyObject *) {
20065 PyErr_SetString(PyExc_TypeError,"Variable NullIcon is read-only.");
20066 return 1;
20067 }
20068
20069
20070 static PyObject *_wrap_NullIcon_get(void) {
20071 PyObject *pyobj;
20072
20073 pyobj = SWIG_NewPointerObj((void *)(&wxNullIcon), SWIGTYPE_p_wxIcon, 0);
20074 return pyobj;
20075 }
20076
20077
20078 static int _wrap_NullCursor_set(PyObject *) {
20079 PyErr_SetString(PyExc_TypeError,"Variable NullCursor is read-only.");
20080 return 1;
20081 }
20082
20083
20084 static PyObject *_wrap_NullCursor_get(void) {
20085 PyObject *pyobj;
20086
20087 pyobj = SWIG_NewPointerObj((void *)(&wxNullCursor), SWIGTYPE_p_wxCursor, 0);
20088 return pyobj;
20089 }
20090
20091
20092 static int _wrap_NullPen_set(PyObject *) {
20093 PyErr_SetString(PyExc_TypeError,"Variable NullPen is read-only.");
20094 return 1;
20095 }
20096
20097
20098 static PyObject *_wrap_NullPen_get(void) {
20099 PyObject *pyobj;
20100
20101 pyobj = SWIG_NewPointerObj((void *)(&wxNullPen), SWIGTYPE_p_wxPen, 0);
20102 return pyobj;
20103 }
20104
20105
20106 static int _wrap_NullBrush_set(PyObject *) {
20107 PyErr_SetString(PyExc_TypeError,"Variable NullBrush is read-only.");
20108 return 1;
20109 }
20110
20111
20112 static PyObject *_wrap_NullBrush_get(void) {
20113 PyObject *pyobj;
20114
20115 pyobj = SWIG_NewPointerObj((void *)(&wxNullBrush), SWIGTYPE_p_wxBrush, 0);
20116 return pyobj;
20117 }
20118
20119
20120 static int _wrap_NullPalette_set(PyObject *) {
20121 PyErr_SetString(PyExc_TypeError,"Variable NullPalette is read-only.");
20122 return 1;
20123 }
20124
20125
20126 static PyObject *_wrap_NullPalette_get(void) {
20127 PyObject *pyobj;
20128
20129 pyobj = SWIG_NewPointerObj((void *)(&wxNullPalette), SWIGTYPE_p_wxPalette, 0);
20130 return pyobj;
20131 }
20132
20133
20134 static int _wrap_NullFont_set(PyObject *) {
20135 PyErr_SetString(PyExc_TypeError,"Variable NullFont is read-only.");
20136 return 1;
20137 }
20138
20139
20140 static PyObject *_wrap_NullFont_get(void) {
20141 PyObject *pyobj;
20142
20143 pyobj = SWIG_NewPointerObj((void *)(&wxNullFont), SWIGTYPE_p_wxFont, 0);
20144 return pyobj;
20145 }
20146
20147
20148 static int _wrap_NullColour_set(PyObject *) {
20149 PyErr_SetString(PyExc_TypeError,"Variable NullColour is read-only.");
20150 return 1;
20151 }
20152
20153
20154 static PyObject *_wrap_NullColour_get(void) {
20155 PyObject *pyobj;
20156
20157 pyobj = SWIG_NewPointerObj((void *)(&wxNullColour), SWIGTYPE_p_wxColour, 0);
20158 return pyobj;
20159 }
20160
20161
20162 static PyObject *_wrap_PenList_AddPen(PyObject *, PyObject *args, PyObject *kwargs) {
20163 PyObject *resultobj;
20164 wxPenList *arg1 = (wxPenList *) 0 ;
20165 wxPen *arg2 = (wxPen *) 0 ;
20166 PyObject * obj0 = 0 ;
20167 PyObject * obj1 = 0 ;
20168 char *kwnames[] = {
20169 (char *) "self",(char *) "pen", NULL
20170 };
20171
20172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_AddPen",kwnames,&obj0,&obj1)) goto fail;
20173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
20174 if (SWIG_arg_fail(1)) SWIG_fail;
20175 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
20176 if (SWIG_arg_fail(2)) SWIG_fail;
20177 {
20178 PyThreadState* __tstate = wxPyBeginAllowThreads();
20179 (arg1)->AddPen(arg2);
20180
20181 wxPyEndAllowThreads(__tstate);
20182 if (PyErr_Occurred()) SWIG_fail;
20183 }
20184 Py_INCREF(Py_None); resultobj = Py_None;
20185 return resultobj;
20186 fail:
20187 return NULL;
20188 }
20189
20190
20191 static PyObject *_wrap_PenList_FindOrCreatePen(PyObject *, PyObject *args, PyObject *kwargs) {
20192 PyObject *resultobj;
20193 wxPenList *arg1 = (wxPenList *) 0 ;
20194 wxColour *arg2 = 0 ;
20195 int arg3 ;
20196 int arg4 ;
20197 wxPen *result;
20198 wxColour temp2 ;
20199 PyObject * obj0 = 0 ;
20200 PyObject * obj1 = 0 ;
20201 PyObject * obj2 = 0 ;
20202 PyObject * obj3 = 0 ;
20203 char *kwnames[] = {
20204 (char *) "self",(char *) "colour",(char *) "width",(char *) "style", NULL
20205 };
20206
20207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PenList_FindOrCreatePen",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
20209 if (SWIG_arg_fail(1)) SWIG_fail;
20210 {
20211 arg2 = &temp2;
20212 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20213 }
20214 {
20215 arg3 = (int)(SWIG_As_int(obj2));
20216 if (SWIG_arg_fail(3)) SWIG_fail;
20217 }
20218 {
20219 arg4 = (int)(SWIG_As_int(obj3));
20220 if (SWIG_arg_fail(4)) SWIG_fail;
20221 }
20222 {
20223 PyThreadState* __tstate = wxPyBeginAllowThreads();
20224 result = (wxPen *)(arg1)->FindOrCreatePen((wxColour const &)*arg2,arg3,arg4);
20225
20226 wxPyEndAllowThreads(__tstate);
20227 if (PyErr_Occurred()) SWIG_fail;
20228 }
20229 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 0);
20230 return resultobj;
20231 fail:
20232 return NULL;
20233 }
20234
20235
20236 static PyObject *_wrap_PenList_RemovePen(PyObject *, PyObject *args, PyObject *kwargs) {
20237 PyObject *resultobj;
20238 wxPenList *arg1 = (wxPenList *) 0 ;
20239 wxPen *arg2 = (wxPen *) 0 ;
20240 PyObject * obj0 = 0 ;
20241 PyObject * obj1 = 0 ;
20242 char *kwnames[] = {
20243 (char *) "self",(char *) "pen", NULL
20244 };
20245
20246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_RemovePen",kwnames,&obj0,&obj1)) goto fail;
20247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
20248 if (SWIG_arg_fail(1)) SWIG_fail;
20249 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
20250 if (SWIG_arg_fail(2)) SWIG_fail;
20251 {
20252 PyThreadState* __tstate = wxPyBeginAllowThreads();
20253 (arg1)->RemovePen(arg2);
20254
20255 wxPyEndAllowThreads(__tstate);
20256 if (PyErr_Occurred()) SWIG_fail;
20257 }
20258 Py_INCREF(Py_None); resultobj = Py_None;
20259 return resultobj;
20260 fail:
20261 return NULL;
20262 }
20263
20264
20265 static PyObject *_wrap_PenList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
20266 PyObject *resultobj;
20267 wxPenList *arg1 = (wxPenList *) 0 ;
20268 int result;
20269 PyObject * obj0 = 0 ;
20270 char *kwnames[] = {
20271 (char *) "self", NULL
20272 };
20273
20274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PenList_GetCount",kwnames,&obj0)) goto fail;
20275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
20276 if (SWIG_arg_fail(1)) SWIG_fail;
20277 {
20278 PyThreadState* __tstate = wxPyBeginAllowThreads();
20279 result = (int)(arg1)->GetCount();
20280
20281 wxPyEndAllowThreads(__tstate);
20282 if (PyErr_Occurred()) SWIG_fail;
20283 }
20284 {
20285 resultobj = SWIG_From_int((int)(result));
20286 }
20287 return resultobj;
20288 fail:
20289 return NULL;
20290 }
20291
20292
20293 static PyObject * PenList_swigregister(PyObject *, PyObject *args) {
20294 PyObject *obj;
20295 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20296 SWIG_TypeClientData(SWIGTYPE_p_wxPenList, obj);
20297 Py_INCREF(obj);
20298 return Py_BuildValue((char *)"");
20299 }
20300 static PyObject *_wrap_BrushList_AddBrush(PyObject *, PyObject *args, PyObject *kwargs) {
20301 PyObject *resultobj;
20302 wxBrushList *arg1 = (wxBrushList *) 0 ;
20303 wxBrush *arg2 = (wxBrush *) 0 ;
20304 PyObject * obj0 = 0 ;
20305 PyObject * obj1 = 0 ;
20306 char *kwnames[] = {
20307 (char *) "self",(char *) "brush", NULL
20308 };
20309
20310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_AddBrush",kwnames,&obj0,&obj1)) goto fail;
20311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
20312 if (SWIG_arg_fail(1)) SWIG_fail;
20313 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
20314 if (SWIG_arg_fail(2)) SWIG_fail;
20315 {
20316 PyThreadState* __tstate = wxPyBeginAllowThreads();
20317 (arg1)->AddBrush(arg2);
20318
20319 wxPyEndAllowThreads(__tstate);
20320 if (PyErr_Occurred()) SWIG_fail;
20321 }
20322 Py_INCREF(Py_None); resultobj = Py_None;
20323 return resultobj;
20324 fail:
20325 return NULL;
20326 }
20327
20328
20329 static PyObject *_wrap_BrushList_FindOrCreateBrush(PyObject *, PyObject *args, PyObject *kwargs) {
20330 PyObject *resultobj;
20331 wxBrushList *arg1 = (wxBrushList *) 0 ;
20332 wxColour *arg2 = 0 ;
20333 int arg3 = (int) wxSOLID ;
20334 wxBrush *result;
20335 wxColour temp2 ;
20336 PyObject * obj0 = 0 ;
20337 PyObject * obj1 = 0 ;
20338 PyObject * obj2 = 0 ;
20339 char *kwnames[] = {
20340 (char *) "self",(char *) "colour",(char *) "style", NULL
20341 };
20342
20343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:BrushList_FindOrCreateBrush",kwnames,&obj0,&obj1,&obj2)) goto fail;
20344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
20345 if (SWIG_arg_fail(1)) SWIG_fail;
20346 {
20347 arg2 = &temp2;
20348 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20349 }
20350 if (obj2) {
20351 {
20352 arg3 = (int)(SWIG_As_int(obj2));
20353 if (SWIG_arg_fail(3)) SWIG_fail;
20354 }
20355 }
20356 {
20357 PyThreadState* __tstate = wxPyBeginAllowThreads();
20358 result = (wxBrush *)(arg1)->FindOrCreateBrush((wxColour const &)*arg2,arg3);
20359
20360 wxPyEndAllowThreads(__tstate);
20361 if (PyErr_Occurred()) SWIG_fail;
20362 }
20363 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 0);
20364 return resultobj;
20365 fail:
20366 return NULL;
20367 }
20368
20369
20370 static PyObject *_wrap_BrushList_RemoveBrush(PyObject *, PyObject *args, PyObject *kwargs) {
20371 PyObject *resultobj;
20372 wxBrushList *arg1 = (wxBrushList *) 0 ;
20373 wxBrush *arg2 = (wxBrush *) 0 ;
20374 PyObject * obj0 = 0 ;
20375 PyObject * obj1 = 0 ;
20376 char *kwnames[] = {
20377 (char *) "self",(char *) "brush", NULL
20378 };
20379
20380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_RemoveBrush",kwnames,&obj0,&obj1)) goto fail;
20381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
20382 if (SWIG_arg_fail(1)) SWIG_fail;
20383 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
20384 if (SWIG_arg_fail(2)) SWIG_fail;
20385 {
20386 PyThreadState* __tstate = wxPyBeginAllowThreads();
20387 (arg1)->RemoveBrush(arg2);
20388
20389 wxPyEndAllowThreads(__tstate);
20390 if (PyErr_Occurred()) SWIG_fail;
20391 }
20392 Py_INCREF(Py_None); resultobj = Py_None;
20393 return resultobj;
20394 fail:
20395 return NULL;
20396 }
20397
20398
20399 static PyObject *_wrap_BrushList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
20400 PyObject *resultobj;
20401 wxBrushList *arg1 = (wxBrushList *) 0 ;
20402 int result;
20403 PyObject * obj0 = 0 ;
20404 char *kwnames[] = {
20405 (char *) "self", NULL
20406 };
20407
20408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BrushList_GetCount",kwnames,&obj0)) goto fail;
20409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
20410 if (SWIG_arg_fail(1)) SWIG_fail;
20411 {
20412 PyThreadState* __tstate = wxPyBeginAllowThreads();
20413 result = (int)(arg1)->GetCount();
20414
20415 wxPyEndAllowThreads(__tstate);
20416 if (PyErr_Occurred()) SWIG_fail;
20417 }
20418 {
20419 resultobj = SWIG_From_int((int)(result));
20420 }
20421 return resultobj;
20422 fail:
20423 return NULL;
20424 }
20425
20426
20427 static PyObject * BrushList_swigregister(PyObject *, PyObject *args) {
20428 PyObject *obj;
20429 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20430 SWIG_TypeClientData(SWIGTYPE_p_wxBrushList, obj);
20431 Py_INCREF(obj);
20432 return Py_BuildValue((char *)"");
20433 }
20434 static PyObject *_wrap_new_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
20435 PyObject *resultobj;
20436 wxColourDatabase *result;
20437 char *kwnames[] = {
20438 NULL
20439 };
20440
20441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ColourDatabase",kwnames)) goto fail;
20442 {
20443 if (!wxPyCheckForApp()) SWIG_fail;
20444 PyThreadState* __tstate = wxPyBeginAllowThreads();
20445 result = (wxColourDatabase *)new wxColourDatabase();
20446
20447 wxPyEndAllowThreads(__tstate);
20448 if (PyErr_Occurred()) SWIG_fail;
20449 }
20450 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourDatabase, 1);
20451 return resultobj;
20452 fail:
20453 return NULL;
20454 }
20455
20456
20457 static PyObject *_wrap_delete_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
20458 PyObject *resultobj;
20459 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20460 PyObject * obj0 = 0 ;
20461 char *kwnames[] = {
20462 (char *) "self", NULL
20463 };
20464
20465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ColourDatabase",kwnames,&obj0)) goto fail;
20466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20467 if (SWIG_arg_fail(1)) SWIG_fail;
20468 {
20469 PyThreadState* __tstate = wxPyBeginAllowThreads();
20470 delete arg1;
20471
20472 wxPyEndAllowThreads(__tstate);
20473 if (PyErr_Occurred()) SWIG_fail;
20474 }
20475 Py_INCREF(Py_None); resultobj = Py_None;
20476 return resultobj;
20477 fail:
20478 return NULL;
20479 }
20480
20481
20482 static PyObject *_wrap_ColourDatabase_Find(PyObject *, PyObject *args, PyObject *kwargs) {
20483 PyObject *resultobj;
20484 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20485 wxString *arg2 = 0 ;
20486 wxColour result;
20487 bool temp2 = false ;
20488 PyObject * obj0 = 0 ;
20489 PyObject * obj1 = 0 ;
20490 char *kwnames[] = {
20491 (char *) "self",(char *) "name", NULL
20492 };
20493
20494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_Find",kwnames,&obj0,&obj1)) goto fail;
20495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20496 if (SWIG_arg_fail(1)) SWIG_fail;
20497 {
20498 arg2 = wxString_in_helper(obj1);
20499 if (arg2 == NULL) SWIG_fail;
20500 temp2 = true;
20501 }
20502 {
20503 PyThreadState* __tstate = wxPyBeginAllowThreads();
20504 result = ((wxColourDatabase const *)arg1)->Find((wxString const &)*arg2);
20505
20506 wxPyEndAllowThreads(__tstate);
20507 if (PyErr_Occurred()) SWIG_fail;
20508 }
20509 {
20510 wxColour * resultptr;
20511 resultptr = new wxColour((wxColour &)(result));
20512 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20513 }
20514 {
20515 if (temp2)
20516 delete arg2;
20517 }
20518 return resultobj;
20519 fail:
20520 {
20521 if (temp2)
20522 delete arg2;
20523 }
20524 return NULL;
20525 }
20526
20527
20528 static PyObject *_wrap_ColourDatabase_FindName(PyObject *, PyObject *args, PyObject *kwargs) {
20529 PyObject *resultobj;
20530 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20531 wxColour *arg2 = 0 ;
20532 wxString result;
20533 wxColour temp2 ;
20534 PyObject * obj0 = 0 ;
20535 PyObject * obj1 = 0 ;
20536 char *kwnames[] = {
20537 (char *) "self",(char *) "colour", NULL
20538 };
20539
20540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_FindName",kwnames,&obj0,&obj1)) goto fail;
20541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20542 if (SWIG_arg_fail(1)) SWIG_fail;
20543 {
20544 arg2 = &temp2;
20545 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20546 }
20547 {
20548 PyThreadState* __tstate = wxPyBeginAllowThreads();
20549 result = ((wxColourDatabase const *)arg1)->FindName((wxColour const &)*arg2);
20550
20551 wxPyEndAllowThreads(__tstate);
20552 if (PyErr_Occurred()) SWIG_fail;
20553 }
20554 {
20555 #if wxUSE_UNICODE
20556 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20557 #else
20558 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20559 #endif
20560 }
20561 return resultobj;
20562 fail:
20563 return NULL;
20564 }
20565
20566
20567 static PyObject *_wrap_ColourDatabase_AddColour(PyObject *, PyObject *args, PyObject *kwargs) {
20568 PyObject *resultobj;
20569 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20570 wxString *arg2 = 0 ;
20571 wxColour *arg3 = 0 ;
20572 bool temp2 = false ;
20573 wxColour temp3 ;
20574 PyObject * obj0 = 0 ;
20575 PyObject * obj1 = 0 ;
20576 PyObject * obj2 = 0 ;
20577 char *kwnames[] = {
20578 (char *) "self",(char *) "name",(char *) "colour", NULL
20579 };
20580
20581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ColourDatabase_AddColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
20582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20583 if (SWIG_arg_fail(1)) SWIG_fail;
20584 {
20585 arg2 = wxString_in_helper(obj1);
20586 if (arg2 == NULL) SWIG_fail;
20587 temp2 = true;
20588 }
20589 {
20590 arg3 = &temp3;
20591 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
20592 }
20593 {
20594 PyThreadState* __tstate = wxPyBeginAllowThreads();
20595 (arg1)->AddColour((wxString const &)*arg2,(wxColour const &)*arg3);
20596
20597 wxPyEndAllowThreads(__tstate);
20598 if (PyErr_Occurred()) SWIG_fail;
20599 }
20600 Py_INCREF(Py_None); resultobj = Py_None;
20601 {
20602 if (temp2)
20603 delete arg2;
20604 }
20605 return resultobj;
20606 fail:
20607 {
20608 if (temp2)
20609 delete arg2;
20610 }
20611 return NULL;
20612 }
20613
20614
20615 static PyObject *_wrap_ColourDatabase_Append(PyObject *, PyObject *args, PyObject *kwargs) {
20616 PyObject *resultobj;
20617 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20618 wxString *arg2 = 0 ;
20619 int arg3 ;
20620 int arg4 ;
20621 int arg5 ;
20622 bool temp2 = false ;
20623 PyObject * obj0 = 0 ;
20624 PyObject * obj1 = 0 ;
20625 PyObject * obj2 = 0 ;
20626 PyObject * obj3 = 0 ;
20627 PyObject * obj4 = 0 ;
20628 char *kwnames[] = {
20629 (char *) "self",(char *) "name",(char *) "red",(char *) "green",(char *) "blue", NULL
20630 };
20631
20632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:ColourDatabase_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20634 if (SWIG_arg_fail(1)) SWIG_fail;
20635 {
20636 arg2 = wxString_in_helper(obj1);
20637 if (arg2 == NULL) SWIG_fail;
20638 temp2 = true;
20639 }
20640 {
20641 arg3 = (int)(SWIG_As_int(obj2));
20642 if (SWIG_arg_fail(3)) SWIG_fail;
20643 }
20644 {
20645 arg4 = (int)(SWIG_As_int(obj3));
20646 if (SWIG_arg_fail(4)) SWIG_fail;
20647 }
20648 {
20649 arg5 = (int)(SWIG_As_int(obj4));
20650 if (SWIG_arg_fail(5)) SWIG_fail;
20651 }
20652 {
20653 PyThreadState* __tstate = wxPyBeginAllowThreads();
20654 wxColourDatabase_Append(arg1,(wxString const &)*arg2,arg3,arg4,arg5);
20655
20656 wxPyEndAllowThreads(__tstate);
20657 if (PyErr_Occurred()) SWIG_fail;
20658 }
20659 Py_INCREF(Py_None); resultobj = Py_None;
20660 {
20661 if (temp2)
20662 delete arg2;
20663 }
20664 return resultobj;
20665 fail:
20666 {
20667 if (temp2)
20668 delete arg2;
20669 }
20670 return NULL;
20671 }
20672
20673
20674 static PyObject * ColourDatabase_swigregister(PyObject *, PyObject *args) {
20675 PyObject *obj;
20676 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20677 SWIG_TypeClientData(SWIGTYPE_p_wxColourDatabase, obj);
20678 Py_INCREF(obj);
20679 return Py_BuildValue((char *)"");
20680 }
20681 static PyObject *_wrap_FontList_AddFont(PyObject *, PyObject *args, PyObject *kwargs) {
20682 PyObject *resultobj;
20683 wxFontList *arg1 = (wxFontList *) 0 ;
20684 wxFont *arg2 = (wxFont *) 0 ;
20685 PyObject * obj0 = 0 ;
20686 PyObject * obj1 = 0 ;
20687 char *kwnames[] = {
20688 (char *) "self",(char *) "font", NULL
20689 };
20690
20691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_AddFont",kwnames,&obj0,&obj1)) goto fail;
20692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20693 if (SWIG_arg_fail(1)) SWIG_fail;
20694 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
20695 if (SWIG_arg_fail(2)) SWIG_fail;
20696 {
20697 PyThreadState* __tstate = wxPyBeginAllowThreads();
20698 (arg1)->AddFont(arg2);
20699
20700 wxPyEndAllowThreads(__tstate);
20701 if (PyErr_Occurred()) SWIG_fail;
20702 }
20703 Py_INCREF(Py_None); resultobj = Py_None;
20704 return resultobj;
20705 fail:
20706 return NULL;
20707 }
20708
20709
20710 static PyObject *_wrap_FontList_FindOrCreateFont(PyObject *, PyObject *args, PyObject *kwargs) {
20711 PyObject *resultobj;
20712 wxFontList *arg1 = (wxFontList *) 0 ;
20713 int arg2 ;
20714 int arg3 ;
20715 int arg4 ;
20716 int arg5 ;
20717 bool arg6 = (bool) false ;
20718 wxString const &arg7_defvalue = wxPyEmptyString ;
20719 wxString *arg7 = (wxString *) &arg7_defvalue ;
20720 wxFontEncoding arg8 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
20721 wxFont *result;
20722 bool temp7 = false ;
20723 PyObject * obj0 = 0 ;
20724 PyObject * obj1 = 0 ;
20725 PyObject * obj2 = 0 ;
20726 PyObject * obj3 = 0 ;
20727 PyObject * obj4 = 0 ;
20728 PyObject * obj5 = 0 ;
20729 PyObject * obj6 = 0 ;
20730 PyObject * obj7 = 0 ;
20731 char *kwnames[] = {
20732 (char *) "self",(char *) "point_size",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "facename",(char *) "encoding", NULL
20733 };
20734
20735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:FontList_FindOrCreateFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20737 if (SWIG_arg_fail(1)) SWIG_fail;
20738 {
20739 arg2 = (int)(SWIG_As_int(obj1));
20740 if (SWIG_arg_fail(2)) SWIG_fail;
20741 }
20742 {
20743 arg3 = (int)(SWIG_As_int(obj2));
20744 if (SWIG_arg_fail(3)) SWIG_fail;
20745 }
20746 {
20747 arg4 = (int)(SWIG_As_int(obj3));
20748 if (SWIG_arg_fail(4)) SWIG_fail;
20749 }
20750 {
20751 arg5 = (int)(SWIG_As_int(obj4));
20752 if (SWIG_arg_fail(5)) SWIG_fail;
20753 }
20754 if (obj5) {
20755 {
20756 arg6 = (bool)(SWIG_As_bool(obj5));
20757 if (SWIG_arg_fail(6)) SWIG_fail;
20758 }
20759 }
20760 if (obj6) {
20761 {
20762 arg7 = wxString_in_helper(obj6);
20763 if (arg7 == NULL) SWIG_fail;
20764 temp7 = true;
20765 }
20766 }
20767 if (obj7) {
20768 {
20769 arg8 = (wxFontEncoding)(SWIG_As_int(obj7));
20770 if (SWIG_arg_fail(8)) SWIG_fail;
20771 }
20772 }
20773 {
20774 PyThreadState* __tstate = wxPyBeginAllowThreads();
20775 result = (wxFont *)(arg1)->FindOrCreateFont(arg2,arg3,arg4,arg5,arg6,(wxString const &)*arg7,(wxFontEncoding )arg8);
20776
20777 wxPyEndAllowThreads(__tstate);
20778 if (PyErr_Occurred()) SWIG_fail;
20779 }
20780 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
20781 {
20782 if (temp7)
20783 delete arg7;
20784 }
20785 return resultobj;
20786 fail:
20787 {
20788 if (temp7)
20789 delete arg7;
20790 }
20791 return NULL;
20792 }
20793
20794
20795 static PyObject *_wrap_FontList_RemoveFont(PyObject *, PyObject *args, PyObject *kwargs) {
20796 PyObject *resultobj;
20797 wxFontList *arg1 = (wxFontList *) 0 ;
20798 wxFont *arg2 = (wxFont *) 0 ;
20799 PyObject * obj0 = 0 ;
20800 PyObject * obj1 = 0 ;
20801 char *kwnames[] = {
20802 (char *) "self",(char *) "font", NULL
20803 };
20804
20805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_RemoveFont",kwnames,&obj0,&obj1)) goto fail;
20806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20807 if (SWIG_arg_fail(1)) SWIG_fail;
20808 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
20809 if (SWIG_arg_fail(2)) SWIG_fail;
20810 {
20811 PyThreadState* __tstate = wxPyBeginAllowThreads();
20812 (arg1)->RemoveFont(arg2);
20813
20814 wxPyEndAllowThreads(__tstate);
20815 if (PyErr_Occurred()) SWIG_fail;
20816 }
20817 Py_INCREF(Py_None); resultobj = Py_None;
20818 return resultobj;
20819 fail:
20820 return NULL;
20821 }
20822
20823
20824 static PyObject *_wrap_FontList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
20825 PyObject *resultobj;
20826 wxFontList *arg1 = (wxFontList *) 0 ;
20827 int result;
20828 PyObject * obj0 = 0 ;
20829 char *kwnames[] = {
20830 (char *) "self", NULL
20831 };
20832
20833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontList_GetCount",kwnames,&obj0)) goto fail;
20834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20835 if (SWIG_arg_fail(1)) SWIG_fail;
20836 {
20837 PyThreadState* __tstate = wxPyBeginAllowThreads();
20838 result = (int)(arg1)->GetCount();
20839
20840 wxPyEndAllowThreads(__tstate);
20841 if (PyErr_Occurred()) SWIG_fail;
20842 }
20843 {
20844 resultobj = SWIG_From_int((int)(result));
20845 }
20846 return resultobj;
20847 fail:
20848 return NULL;
20849 }
20850
20851
20852 static PyObject * FontList_swigregister(PyObject *, PyObject *args) {
20853 PyObject *obj;
20854 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20855 SWIG_TypeClientData(SWIGTYPE_p_wxFontList, obj);
20856 Py_INCREF(obj);
20857 return Py_BuildValue((char *)"");
20858 }
20859 static int _wrap_TheFontList_set(PyObject *) {
20860 PyErr_SetString(PyExc_TypeError,"Variable TheFontList is read-only.");
20861 return 1;
20862 }
20863
20864
20865 static PyObject *_wrap_TheFontList_get(void) {
20866 PyObject *pyobj;
20867
20868 pyobj = SWIG_NewPointerObj((void *)(wxTheFontList), SWIGTYPE_p_wxFontList, 0);
20869 return pyobj;
20870 }
20871
20872
20873 static int _wrap_ThePenList_set(PyObject *) {
20874 PyErr_SetString(PyExc_TypeError,"Variable ThePenList is read-only.");
20875 return 1;
20876 }
20877
20878
20879 static PyObject *_wrap_ThePenList_get(void) {
20880 PyObject *pyobj;
20881
20882 pyobj = SWIG_NewPointerObj((void *)(wxThePenList), SWIGTYPE_p_wxPenList, 0);
20883 return pyobj;
20884 }
20885
20886
20887 static int _wrap_TheBrushList_set(PyObject *) {
20888 PyErr_SetString(PyExc_TypeError,"Variable TheBrushList is read-only.");
20889 return 1;
20890 }
20891
20892
20893 static PyObject *_wrap_TheBrushList_get(void) {
20894 PyObject *pyobj;
20895
20896 pyobj = SWIG_NewPointerObj((void *)(wxTheBrushList), SWIGTYPE_p_wxBrushList, 0);
20897 return pyobj;
20898 }
20899
20900
20901 static int _wrap_TheColourDatabase_set(PyObject *) {
20902 PyErr_SetString(PyExc_TypeError,"Variable TheColourDatabase is read-only.");
20903 return 1;
20904 }
20905
20906
20907 static PyObject *_wrap_TheColourDatabase_get(void) {
20908 PyObject *pyobj;
20909
20910 pyobj = SWIG_NewPointerObj((void *)(wxTheColourDatabase), SWIGTYPE_p_wxColourDatabase, 0);
20911 return pyobj;
20912 }
20913
20914
20915 static PyObject *_wrap_new_Effects(PyObject *, PyObject *args, PyObject *kwargs) {
20916 PyObject *resultobj;
20917 wxEffects *result;
20918 char *kwnames[] = {
20919 NULL
20920 };
20921
20922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Effects",kwnames)) goto fail;
20923 {
20924 PyThreadState* __tstate = wxPyBeginAllowThreads();
20925 result = (wxEffects *)new wxEffects();
20926
20927 wxPyEndAllowThreads(__tstate);
20928 if (PyErr_Occurred()) SWIG_fail;
20929 }
20930 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEffects, 1);
20931 return resultobj;
20932 fail:
20933 return NULL;
20934 }
20935
20936
20937 static PyObject *_wrap_Effects_GetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
20938 PyObject *resultobj;
20939 wxEffects *arg1 = (wxEffects *) 0 ;
20940 wxColour result;
20941 PyObject * obj0 = 0 ;
20942 char *kwnames[] = {
20943 (char *) "self", NULL
20944 };
20945
20946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetHighlightColour",kwnames,&obj0)) goto fail;
20947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20948 if (SWIG_arg_fail(1)) SWIG_fail;
20949 {
20950 PyThreadState* __tstate = wxPyBeginAllowThreads();
20951 result = ((wxEffects const *)arg1)->GetHighlightColour();
20952
20953 wxPyEndAllowThreads(__tstate);
20954 if (PyErr_Occurred()) SWIG_fail;
20955 }
20956 {
20957 wxColour * resultptr;
20958 resultptr = new wxColour((wxColour &)(result));
20959 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20960 }
20961 return resultobj;
20962 fail:
20963 return NULL;
20964 }
20965
20966
20967 static PyObject *_wrap_Effects_GetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20968 PyObject *resultobj;
20969 wxEffects *arg1 = (wxEffects *) 0 ;
20970 wxColour result;
20971 PyObject * obj0 = 0 ;
20972 char *kwnames[] = {
20973 (char *) "self", NULL
20974 };
20975
20976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetLightShadow",kwnames,&obj0)) goto fail;
20977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20978 if (SWIG_arg_fail(1)) SWIG_fail;
20979 {
20980 PyThreadState* __tstate = wxPyBeginAllowThreads();
20981 result = ((wxEffects const *)arg1)->GetLightShadow();
20982
20983 wxPyEndAllowThreads(__tstate);
20984 if (PyErr_Occurred()) SWIG_fail;
20985 }
20986 {
20987 wxColour * resultptr;
20988 resultptr = new wxColour((wxColour &)(result));
20989 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20990 }
20991 return resultobj;
20992 fail:
20993 return NULL;
20994 }
20995
20996
20997 static PyObject *_wrap_Effects_GetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
20998 PyObject *resultobj;
20999 wxEffects *arg1 = (wxEffects *) 0 ;
21000 wxColour result;
21001 PyObject * obj0 = 0 ;
21002 char *kwnames[] = {
21003 (char *) "self", NULL
21004 };
21005
21006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetFaceColour",kwnames,&obj0)) goto fail;
21007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21008 if (SWIG_arg_fail(1)) SWIG_fail;
21009 {
21010 PyThreadState* __tstate = wxPyBeginAllowThreads();
21011 result = ((wxEffects const *)arg1)->GetFaceColour();
21012
21013 wxPyEndAllowThreads(__tstate);
21014 if (PyErr_Occurred()) SWIG_fail;
21015 }
21016 {
21017 wxColour * resultptr;
21018 resultptr = new wxColour((wxColour &)(result));
21019 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
21020 }
21021 return resultobj;
21022 fail:
21023 return NULL;
21024 }
21025
21026
21027 static PyObject *_wrap_Effects_GetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21028 PyObject *resultobj;
21029 wxEffects *arg1 = (wxEffects *) 0 ;
21030 wxColour result;
21031 PyObject * obj0 = 0 ;
21032 char *kwnames[] = {
21033 (char *) "self", NULL
21034 };
21035
21036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetMediumShadow",kwnames,&obj0)) goto fail;
21037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21038 if (SWIG_arg_fail(1)) SWIG_fail;
21039 {
21040 PyThreadState* __tstate = wxPyBeginAllowThreads();
21041 result = ((wxEffects const *)arg1)->GetMediumShadow();
21042
21043 wxPyEndAllowThreads(__tstate);
21044 if (PyErr_Occurred()) SWIG_fail;
21045 }
21046 {
21047 wxColour * resultptr;
21048 resultptr = new wxColour((wxColour &)(result));
21049 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
21050 }
21051 return resultobj;
21052 fail:
21053 return NULL;
21054 }
21055
21056
21057 static PyObject *_wrap_Effects_GetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21058 PyObject *resultobj;
21059 wxEffects *arg1 = (wxEffects *) 0 ;
21060 wxColour result;
21061 PyObject * obj0 = 0 ;
21062 char *kwnames[] = {
21063 (char *) "self", NULL
21064 };
21065
21066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetDarkShadow",kwnames,&obj0)) goto fail;
21067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21068 if (SWIG_arg_fail(1)) SWIG_fail;
21069 {
21070 PyThreadState* __tstate = wxPyBeginAllowThreads();
21071 result = ((wxEffects const *)arg1)->GetDarkShadow();
21072
21073 wxPyEndAllowThreads(__tstate);
21074 if (PyErr_Occurred()) SWIG_fail;
21075 }
21076 {
21077 wxColour * resultptr;
21078 resultptr = new wxColour((wxColour &)(result));
21079 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
21080 }
21081 return resultobj;
21082 fail:
21083 return NULL;
21084 }
21085
21086
21087 static PyObject *_wrap_Effects_SetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
21088 PyObject *resultobj;
21089 wxEffects *arg1 = (wxEffects *) 0 ;
21090 wxColour *arg2 = 0 ;
21091 wxColour temp2 ;
21092 PyObject * obj0 = 0 ;
21093 PyObject * obj1 = 0 ;
21094 char *kwnames[] = {
21095 (char *) "self",(char *) "c", NULL
21096 };
21097
21098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetHighlightColour",kwnames,&obj0,&obj1)) goto fail;
21099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21100 if (SWIG_arg_fail(1)) SWIG_fail;
21101 {
21102 arg2 = &temp2;
21103 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21104 }
21105 {
21106 PyThreadState* __tstate = wxPyBeginAllowThreads();
21107 (arg1)->SetHighlightColour((wxColour const &)*arg2);
21108
21109 wxPyEndAllowThreads(__tstate);
21110 if (PyErr_Occurred()) SWIG_fail;
21111 }
21112 Py_INCREF(Py_None); resultobj = Py_None;
21113 return resultobj;
21114 fail:
21115 return NULL;
21116 }
21117
21118
21119 static PyObject *_wrap_Effects_SetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21120 PyObject *resultobj;
21121 wxEffects *arg1 = (wxEffects *) 0 ;
21122 wxColour *arg2 = 0 ;
21123 wxColour temp2 ;
21124 PyObject * obj0 = 0 ;
21125 PyObject * obj1 = 0 ;
21126 char *kwnames[] = {
21127 (char *) "self",(char *) "c", NULL
21128 };
21129
21130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetLightShadow",kwnames,&obj0,&obj1)) goto fail;
21131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21132 if (SWIG_arg_fail(1)) SWIG_fail;
21133 {
21134 arg2 = &temp2;
21135 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21136 }
21137 {
21138 PyThreadState* __tstate = wxPyBeginAllowThreads();
21139 (arg1)->SetLightShadow((wxColour const &)*arg2);
21140
21141 wxPyEndAllowThreads(__tstate);
21142 if (PyErr_Occurred()) SWIG_fail;
21143 }
21144 Py_INCREF(Py_None); resultobj = Py_None;
21145 return resultobj;
21146 fail:
21147 return NULL;
21148 }
21149
21150
21151 static PyObject *_wrap_Effects_SetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
21152 PyObject *resultobj;
21153 wxEffects *arg1 = (wxEffects *) 0 ;
21154 wxColour *arg2 = 0 ;
21155 wxColour temp2 ;
21156 PyObject * obj0 = 0 ;
21157 PyObject * obj1 = 0 ;
21158 char *kwnames[] = {
21159 (char *) "self",(char *) "c", NULL
21160 };
21161
21162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetFaceColour",kwnames,&obj0,&obj1)) goto fail;
21163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21164 if (SWIG_arg_fail(1)) SWIG_fail;
21165 {
21166 arg2 = &temp2;
21167 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21168 }
21169 {
21170 PyThreadState* __tstate = wxPyBeginAllowThreads();
21171 (arg1)->SetFaceColour((wxColour const &)*arg2);
21172
21173 wxPyEndAllowThreads(__tstate);
21174 if (PyErr_Occurred()) SWIG_fail;
21175 }
21176 Py_INCREF(Py_None); resultobj = Py_None;
21177 return resultobj;
21178 fail:
21179 return NULL;
21180 }
21181
21182
21183 static PyObject *_wrap_Effects_SetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21184 PyObject *resultobj;
21185 wxEffects *arg1 = (wxEffects *) 0 ;
21186 wxColour *arg2 = 0 ;
21187 wxColour temp2 ;
21188 PyObject * obj0 = 0 ;
21189 PyObject * obj1 = 0 ;
21190 char *kwnames[] = {
21191 (char *) "self",(char *) "c", NULL
21192 };
21193
21194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetMediumShadow",kwnames,&obj0,&obj1)) goto fail;
21195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21196 if (SWIG_arg_fail(1)) SWIG_fail;
21197 {
21198 arg2 = &temp2;
21199 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21200 }
21201 {
21202 PyThreadState* __tstate = wxPyBeginAllowThreads();
21203 (arg1)->SetMediumShadow((wxColour const &)*arg2);
21204
21205 wxPyEndAllowThreads(__tstate);
21206 if (PyErr_Occurred()) SWIG_fail;
21207 }
21208 Py_INCREF(Py_None); resultobj = Py_None;
21209 return resultobj;
21210 fail:
21211 return NULL;
21212 }
21213
21214
21215 static PyObject *_wrap_Effects_SetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21216 PyObject *resultobj;
21217 wxEffects *arg1 = (wxEffects *) 0 ;
21218 wxColour *arg2 = 0 ;
21219 wxColour temp2 ;
21220 PyObject * obj0 = 0 ;
21221 PyObject * obj1 = 0 ;
21222 char *kwnames[] = {
21223 (char *) "self",(char *) "c", NULL
21224 };
21225
21226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetDarkShadow",kwnames,&obj0,&obj1)) goto fail;
21227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21228 if (SWIG_arg_fail(1)) SWIG_fail;
21229 {
21230 arg2 = &temp2;
21231 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21232 }
21233 {
21234 PyThreadState* __tstate = wxPyBeginAllowThreads();
21235 (arg1)->SetDarkShadow((wxColour const &)*arg2);
21236
21237 wxPyEndAllowThreads(__tstate);
21238 if (PyErr_Occurred()) SWIG_fail;
21239 }
21240 Py_INCREF(Py_None); resultobj = Py_None;
21241 return resultobj;
21242 fail:
21243 return NULL;
21244 }
21245
21246
21247 static PyObject *_wrap_Effects_Set(PyObject *, PyObject *args, PyObject *kwargs) {
21248 PyObject *resultobj;
21249 wxEffects *arg1 = (wxEffects *) 0 ;
21250 wxColour *arg2 = 0 ;
21251 wxColour *arg3 = 0 ;
21252 wxColour *arg4 = 0 ;
21253 wxColour *arg5 = 0 ;
21254 wxColour *arg6 = 0 ;
21255 wxColour temp2 ;
21256 wxColour temp3 ;
21257 wxColour temp4 ;
21258 wxColour temp5 ;
21259 wxColour temp6 ;
21260 PyObject * obj0 = 0 ;
21261 PyObject * obj1 = 0 ;
21262 PyObject * obj2 = 0 ;
21263 PyObject * obj3 = 0 ;
21264 PyObject * obj4 = 0 ;
21265 PyObject * obj5 = 0 ;
21266 char *kwnames[] = {
21267 (char *) "self",(char *) "highlightColour",(char *) "lightShadow",(char *) "faceColour",(char *) "mediumShadow",(char *) "darkShadow", NULL
21268 };
21269
21270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Effects_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
21271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21272 if (SWIG_arg_fail(1)) SWIG_fail;
21273 {
21274 arg2 = &temp2;
21275 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21276 }
21277 {
21278 arg3 = &temp3;
21279 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
21280 }
21281 {
21282 arg4 = &temp4;
21283 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
21284 }
21285 {
21286 arg5 = &temp5;
21287 if ( ! wxColour_helper(obj4, &arg5)) SWIG_fail;
21288 }
21289 {
21290 arg6 = &temp6;
21291 if ( ! wxColour_helper(obj5, &arg6)) SWIG_fail;
21292 }
21293 {
21294 PyThreadState* __tstate = wxPyBeginAllowThreads();
21295 (arg1)->Set((wxColour const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,(wxColour const &)*arg5,(wxColour const &)*arg6);
21296
21297 wxPyEndAllowThreads(__tstate);
21298 if (PyErr_Occurred()) SWIG_fail;
21299 }
21300 Py_INCREF(Py_None); resultobj = Py_None;
21301 return resultobj;
21302 fail:
21303 return NULL;
21304 }
21305
21306
21307 static PyObject *_wrap_Effects_DrawSunkenEdge(PyObject *, PyObject *args, PyObject *kwargs) {
21308 PyObject *resultobj;
21309 wxEffects *arg1 = (wxEffects *) 0 ;
21310 wxDC *arg2 = 0 ;
21311 wxRect *arg3 = 0 ;
21312 int arg4 = (int) 1 ;
21313 wxRect temp3 ;
21314 PyObject * obj0 = 0 ;
21315 PyObject * obj1 = 0 ;
21316 PyObject * obj2 = 0 ;
21317 PyObject * obj3 = 0 ;
21318 char *kwnames[] = {
21319 (char *) "self",(char *) "dc",(char *) "rect",(char *) "borderSize", NULL
21320 };
21321
21322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Effects_DrawSunkenEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21324 if (SWIG_arg_fail(1)) SWIG_fail;
21325 {
21326 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21327 if (SWIG_arg_fail(2)) SWIG_fail;
21328 if (arg2 == NULL) {
21329 SWIG_null_ref("wxDC");
21330 }
21331 if (SWIG_arg_fail(2)) SWIG_fail;
21332 }
21333 {
21334 arg3 = &temp3;
21335 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
21336 }
21337 if (obj3) {
21338 {
21339 arg4 = (int)(SWIG_As_int(obj3));
21340 if (SWIG_arg_fail(4)) SWIG_fail;
21341 }
21342 }
21343 {
21344 PyThreadState* __tstate = wxPyBeginAllowThreads();
21345 (arg1)->DrawSunkenEdge(*arg2,(wxRect const &)*arg3,arg4);
21346
21347 wxPyEndAllowThreads(__tstate);
21348 if (PyErr_Occurred()) SWIG_fail;
21349 }
21350 Py_INCREF(Py_None); resultobj = Py_None;
21351 return resultobj;
21352 fail:
21353 return NULL;
21354 }
21355
21356
21357 static PyObject *_wrap_Effects_TileBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
21358 PyObject *resultobj;
21359 wxEffects *arg1 = (wxEffects *) 0 ;
21360 wxRect *arg2 = 0 ;
21361 wxDC *arg3 = 0 ;
21362 wxBitmap *arg4 = 0 ;
21363 bool result;
21364 wxRect temp2 ;
21365 PyObject * obj0 = 0 ;
21366 PyObject * obj1 = 0 ;
21367 PyObject * obj2 = 0 ;
21368 PyObject * obj3 = 0 ;
21369 char *kwnames[] = {
21370 (char *) "self",(char *) "rect",(char *) "dc",(char *) "bitmap", NULL
21371 };
21372
21373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Effects_TileBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21375 if (SWIG_arg_fail(1)) SWIG_fail;
21376 {
21377 arg2 = &temp2;
21378 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
21379 }
21380 {
21381 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21382 if (SWIG_arg_fail(3)) SWIG_fail;
21383 if (arg3 == NULL) {
21384 SWIG_null_ref("wxDC");
21385 }
21386 if (SWIG_arg_fail(3)) SWIG_fail;
21387 }
21388 {
21389 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
21390 if (SWIG_arg_fail(4)) SWIG_fail;
21391 if (arg4 == NULL) {
21392 SWIG_null_ref("wxBitmap");
21393 }
21394 if (SWIG_arg_fail(4)) SWIG_fail;
21395 }
21396 {
21397 PyThreadState* __tstate = wxPyBeginAllowThreads();
21398 result = (bool)(arg1)->TileBitmap((wxRect const &)*arg2,*arg3,*arg4);
21399
21400 wxPyEndAllowThreads(__tstate);
21401 if (PyErr_Occurred()) SWIG_fail;
21402 }
21403 {
21404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21405 }
21406 return resultobj;
21407 fail:
21408 return NULL;
21409 }
21410
21411
21412 static PyObject * Effects_swigregister(PyObject *, PyObject *args) {
21413 PyObject *obj;
21414 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21415 SWIG_TypeClientData(SWIGTYPE_p_wxEffects, obj);
21416 Py_INCREF(obj);
21417 return Py_BuildValue((char *)"");
21418 }
21419 static PyMethodDef SwigMethods[] = {
21420 { (char *)"new_GDIObject", (PyCFunction) _wrap_new_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
21421 { (char *)"delete_GDIObject", (PyCFunction) _wrap_delete_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
21422 { (char *)"GDIObject_GetVisible", (PyCFunction) _wrap_GDIObject_GetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
21423 { (char *)"GDIObject_SetVisible", (PyCFunction) _wrap_GDIObject_SetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
21424 { (char *)"GDIObject_IsNull", (PyCFunction) _wrap_GDIObject_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
21425 { (char *)"GDIObject_swigregister", GDIObject_swigregister, METH_VARARGS, NULL},
21426 { (char *)"new_Colour", (PyCFunction) _wrap_new_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
21427 { (char *)"new_NamedColour", (PyCFunction) _wrap_new_NamedColour, METH_VARARGS | METH_KEYWORDS, NULL},
21428 { (char *)"new_ColourRGB", (PyCFunction) _wrap_new_ColourRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21429 { (char *)"delete_Colour", (PyCFunction) _wrap_delete_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
21430 { (char *)"Colour_Red", (PyCFunction) _wrap_Colour_Red, METH_VARARGS | METH_KEYWORDS, NULL},
21431 { (char *)"Colour_Green", (PyCFunction) _wrap_Colour_Green, METH_VARARGS | METH_KEYWORDS, NULL},
21432 { (char *)"Colour_Blue", (PyCFunction) _wrap_Colour_Blue, METH_VARARGS | METH_KEYWORDS, NULL},
21433 { (char *)"Colour_Ok", (PyCFunction) _wrap_Colour_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21434 { (char *)"Colour_Set", (PyCFunction) _wrap_Colour_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21435 { (char *)"Colour_SetRGB", (PyCFunction) _wrap_Colour_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21436 { (char *)"Colour_SetFromName", (PyCFunction) _wrap_Colour_SetFromName, METH_VARARGS | METH_KEYWORDS, NULL},
21437 { (char *)"Colour_GetPixel", (PyCFunction) _wrap_Colour_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
21438 { (char *)"Colour___eq__", (PyCFunction) _wrap_Colour___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21439 { (char *)"Colour___ne__", (PyCFunction) _wrap_Colour___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21440 { (char *)"Colour_Get", (PyCFunction) _wrap_Colour_Get, METH_VARARGS | METH_KEYWORDS, NULL},
21441 { (char *)"Colour_GetRGB", (PyCFunction) _wrap_Colour_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21442 { (char *)"Colour_swigregister", Colour_swigregister, METH_VARARGS, NULL},
21443 { (char *)"new_Palette", (PyCFunction) _wrap_new_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
21444 { (char *)"delete_Palette", (PyCFunction) _wrap_delete_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
21445 { (char *)"Palette_GetPixel", (PyCFunction) _wrap_Palette_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
21446 { (char *)"Palette_GetRGB", (PyCFunction) _wrap_Palette_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21447 { (char *)"Palette_GetColoursCount", (PyCFunction) _wrap_Palette_GetColoursCount, METH_VARARGS | METH_KEYWORDS, NULL},
21448 { (char *)"Palette_Ok", (PyCFunction) _wrap_Palette_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21449 { (char *)"Palette_swigregister", Palette_swigregister, METH_VARARGS, NULL},
21450 { (char *)"new_Pen", (PyCFunction) _wrap_new_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
21451 { (char *)"delete_Pen", (PyCFunction) _wrap_delete_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
21452 { (char *)"Pen_GetCap", (PyCFunction) _wrap_Pen_GetCap, METH_VARARGS | METH_KEYWORDS, NULL},
21453 { (char *)"Pen_GetColour", (PyCFunction) _wrap_Pen_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21454 { (char *)"Pen_GetJoin", (PyCFunction) _wrap_Pen_GetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
21455 { (char *)"Pen_GetStyle", (PyCFunction) _wrap_Pen_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21456 { (char *)"Pen_GetWidth", (PyCFunction) _wrap_Pen_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21457 { (char *)"Pen_Ok", (PyCFunction) _wrap_Pen_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21458 { (char *)"Pen_SetCap", (PyCFunction) _wrap_Pen_SetCap, METH_VARARGS | METH_KEYWORDS, NULL},
21459 { (char *)"Pen_SetColour", (PyCFunction) _wrap_Pen_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21460 { (char *)"Pen_SetJoin", (PyCFunction) _wrap_Pen_SetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
21461 { (char *)"Pen_SetStyle", (PyCFunction) _wrap_Pen_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21462 { (char *)"Pen_SetWidth", (PyCFunction) _wrap_Pen_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21463 { (char *)"Pen_SetDashes", (PyCFunction) _wrap_Pen_SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
21464 { (char *)"Pen_GetDashes", (PyCFunction) _wrap_Pen_GetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
21465 { (char *)"Pen__SetDashes", (PyCFunction) _wrap_Pen__SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
21466 { (char *)"Pen_GetDashCount", (PyCFunction) _wrap_Pen_GetDashCount, METH_VARARGS | METH_KEYWORDS, NULL},
21467 { (char *)"Pen_GetStipple", (PyCFunction) _wrap_Pen_GetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
21468 { (char *)"Pen_SetStipple", (PyCFunction) _wrap_Pen_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
21469 { (char *)"Pen___eq__", (PyCFunction) _wrap_Pen___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21470 { (char *)"Pen___ne__", (PyCFunction) _wrap_Pen___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21471 { (char *)"Pen_swigregister", Pen_swigregister, METH_VARARGS, NULL},
21472 { (char *)"new_Brush", (PyCFunction) _wrap_new_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
21473 { (char *)"delete_Brush", (PyCFunction) _wrap_delete_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
21474 { (char *)"Brush_SetColour", (PyCFunction) _wrap_Brush_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21475 { (char *)"Brush_SetStyle", (PyCFunction) _wrap_Brush_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21476 { (char *)"Brush_SetStipple", (PyCFunction) _wrap_Brush_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
21477 { (char *)"Brush_GetColour", (PyCFunction) _wrap_Brush_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21478 { (char *)"Brush_GetStyle", (PyCFunction) _wrap_Brush_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21479 { (char *)"Brush_GetStipple", (PyCFunction) _wrap_Brush_GetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
21480 { (char *)"Brush_IsHatch", (PyCFunction) _wrap_Brush_IsHatch, METH_VARARGS | METH_KEYWORDS, NULL},
21481 { (char *)"Brush_Ok", (PyCFunction) _wrap_Brush_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21482 { (char *)"Brush_swigregister", Brush_swigregister, METH_VARARGS, NULL},
21483 { (char *)"new_Bitmap", (PyCFunction) _wrap_new_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21484 { (char *)"delete_Bitmap", (PyCFunction) _wrap_delete_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21485 { (char *)"new_EmptyBitmap", (PyCFunction) _wrap_new_EmptyBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21486 { (char *)"new_BitmapFromIcon", (PyCFunction) _wrap_new_BitmapFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21487 { (char *)"new_BitmapFromImage", (PyCFunction) _wrap_new_BitmapFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
21488 { (char *)"new_BitmapFromXPMData", (PyCFunction) _wrap_new_BitmapFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
21489 { (char *)"new_BitmapFromBits", (PyCFunction) _wrap_new_BitmapFromBits, METH_VARARGS | METH_KEYWORDS, NULL},
21490 { (char *)"Bitmap_GetHandle", (PyCFunction) _wrap_Bitmap_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
21491 { (char *)"Bitmap_SetHandle", (PyCFunction) _wrap_Bitmap_SetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
21492 { (char *)"Bitmap_Ok", (PyCFunction) _wrap_Bitmap_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21493 { (char *)"Bitmap_GetWidth", (PyCFunction) _wrap_Bitmap_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21494 { (char *)"Bitmap_GetHeight", (PyCFunction) _wrap_Bitmap_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21495 { (char *)"Bitmap_GetDepth", (PyCFunction) _wrap_Bitmap_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21496 { (char *)"Bitmap_GetSize", (PyCFunction) _wrap_Bitmap_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21497 { (char *)"Bitmap_ConvertToImage", (PyCFunction) _wrap_Bitmap_ConvertToImage, METH_VARARGS | METH_KEYWORDS, NULL},
21498 { (char *)"Bitmap_GetMask", (PyCFunction) _wrap_Bitmap_GetMask, METH_VARARGS | METH_KEYWORDS, NULL},
21499 { (char *)"Bitmap_SetMask", (PyCFunction) _wrap_Bitmap_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
21500 { (char *)"Bitmap_SetMaskColour", (PyCFunction) _wrap_Bitmap_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
21501 { (char *)"Bitmap_GetSubBitmap", (PyCFunction) _wrap_Bitmap_GetSubBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21502 { (char *)"Bitmap_SaveFile", (PyCFunction) _wrap_Bitmap_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
21503 { (char *)"Bitmap_LoadFile", (PyCFunction) _wrap_Bitmap_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
21504 { (char *)"Bitmap_GetPalette", (PyCFunction) _wrap_Bitmap_GetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
21505 { (char *)"Bitmap_SetPalette", (PyCFunction) _wrap_Bitmap_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
21506 { (char *)"Bitmap_CopyFromIcon", (PyCFunction) _wrap_Bitmap_CopyFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21507 { (char *)"Bitmap_SetHeight", (PyCFunction) _wrap_Bitmap_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21508 { (char *)"Bitmap_SetWidth", (PyCFunction) _wrap_Bitmap_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21509 { (char *)"Bitmap_SetDepth", (PyCFunction) _wrap_Bitmap_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21510 { (char *)"Bitmap_SetSize", (PyCFunction) _wrap_Bitmap_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21511 { (char *)"Bitmap_CopyFromCursor", (PyCFunction) _wrap_Bitmap_CopyFromCursor, METH_VARARGS | METH_KEYWORDS, NULL},
21512 { (char *)"Bitmap_GetQuality", (PyCFunction) _wrap_Bitmap_GetQuality, METH_VARARGS | METH_KEYWORDS, NULL},
21513 { (char *)"Bitmap_SetQuality", (PyCFunction) _wrap_Bitmap_SetQuality, METH_VARARGS | METH_KEYWORDS, NULL},
21514 { (char *)"Bitmap___eq__", (PyCFunction) _wrap_Bitmap___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21515 { (char *)"Bitmap___ne__", (PyCFunction) _wrap_Bitmap___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21516 { (char *)"Bitmap_swigregister", Bitmap_swigregister, METH_VARARGS, NULL},
21517 { (char *)"new_Mask", (PyCFunction) _wrap_new_Mask, METH_VARARGS | METH_KEYWORDS, NULL},
21518 { (char *)"Mask_swigregister", Mask_swigregister, METH_VARARGS, NULL},
21519 { (char *)"new_Icon", (PyCFunction) _wrap_new_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
21520 { (char *)"delete_Icon", (PyCFunction) _wrap_delete_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
21521 { (char *)"new_EmptyIcon", (PyCFunction) _wrap_new_EmptyIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21522 { (char *)"new_IconFromLocation", (PyCFunction) _wrap_new_IconFromLocation, METH_VARARGS | METH_KEYWORDS, NULL},
21523 { (char *)"new_IconFromBitmap", (PyCFunction) _wrap_new_IconFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21524 { (char *)"new_IconFromXPMData", (PyCFunction) _wrap_new_IconFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
21525 { (char *)"Icon_LoadFile", (PyCFunction) _wrap_Icon_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
21526 { (char *)"Icon_GetHandle", (PyCFunction) _wrap_Icon_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
21527 { (char *)"Icon_SetHandle", (PyCFunction) _wrap_Icon_SetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
21528 { (char *)"Icon_Ok", (PyCFunction) _wrap_Icon_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21529 { (char *)"Icon_GetWidth", (PyCFunction) _wrap_Icon_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21530 { (char *)"Icon_GetHeight", (PyCFunction) _wrap_Icon_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21531 { (char *)"Icon_GetDepth", (PyCFunction) _wrap_Icon_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21532 { (char *)"Icon_SetWidth", (PyCFunction) _wrap_Icon_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21533 { (char *)"Icon_SetHeight", (PyCFunction) _wrap_Icon_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21534 { (char *)"Icon_SetDepth", (PyCFunction) _wrap_Icon_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21535 { (char *)"Icon_SetSize", (PyCFunction) _wrap_Icon_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21536 { (char *)"Icon_CopyFromBitmap", (PyCFunction) _wrap_Icon_CopyFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21537 { (char *)"Icon_swigregister", Icon_swigregister, METH_VARARGS, NULL},
21538 { (char *)"new_IconLocation", (PyCFunction) _wrap_new_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
21539 { (char *)"delete_IconLocation", (PyCFunction) _wrap_delete_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
21540 { (char *)"IconLocation_IsOk", (PyCFunction) _wrap_IconLocation_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
21541 { (char *)"IconLocation_SetFileName", (PyCFunction) _wrap_IconLocation_SetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
21542 { (char *)"IconLocation_GetFileName", (PyCFunction) _wrap_IconLocation_GetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
21543 { (char *)"IconLocation_SetIndex", (PyCFunction) _wrap_IconLocation_SetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
21544 { (char *)"IconLocation_GetIndex", (PyCFunction) _wrap_IconLocation_GetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
21545 { (char *)"IconLocation_swigregister", IconLocation_swigregister, METH_VARARGS, NULL},
21546 { (char *)"new_IconBundle", (PyCFunction) _wrap_new_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
21547 { (char *)"new_IconBundleFromFile", (PyCFunction) _wrap_new_IconBundleFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
21548 { (char *)"new_IconBundleFromIcon", (PyCFunction) _wrap_new_IconBundleFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21549 { (char *)"delete_IconBundle", (PyCFunction) _wrap_delete_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
21550 { (char *)"IconBundle_AddIcon", (PyCFunction) _wrap_IconBundle_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21551 { (char *)"IconBundle_AddIconFromFile", (PyCFunction) _wrap_IconBundle_AddIconFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
21552 { (char *)"IconBundle_GetIcon", (PyCFunction) _wrap_IconBundle_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21553 { (char *)"IconBundle_swigregister", IconBundle_swigregister, METH_VARARGS, NULL},
21554 { (char *)"new_Cursor", (PyCFunction) _wrap_new_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
21555 { (char *)"delete_Cursor", (PyCFunction) _wrap_delete_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
21556 { (char *)"new_StockCursor", (PyCFunction) _wrap_new_StockCursor, METH_VARARGS | METH_KEYWORDS, NULL},
21557 { (char *)"new_CursorFromImage", (PyCFunction) _wrap_new_CursorFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
21558 { (char *)"Cursor_GetHandle", (PyCFunction) _wrap_Cursor_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
21559 { (char *)"Cursor_SetHandle", (PyCFunction) _wrap_Cursor_SetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
21560 { (char *)"Cursor_Ok", (PyCFunction) _wrap_Cursor_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21561 { (char *)"Cursor_GetWidth", (PyCFunction) _wrap_Cursor_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21562 { (char *)"Cursor_GetHeight", (PyCFunction) _wrap_Cursor_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21563 { (char *)"Cursor_GetDepth", (PyCFunction) _wrap_Cursor_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21564 { (char *)"Cursor_SetWidth", (PyCFunction) _wrap_Cursor_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21565 { (char *)"Cursor_SetHeight", (PyCFunction) _wrap_Cursor_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21566 { (char *)"Cursor_SetDepth", (PyCFunction) _wrap_Cursor_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21567 { (char *)"Cursor_SetSize", (PyCFunction) _wrap_Cursor_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21568 { (char *)"Cursor_swigregister", Cursor_swigregister, METH_VARARGS, NULL},
21569 { (char *)"new_Region", (PyCFunction) _wrap_new_Region, METH_VARARGS | METH_KEYWORDS, NULL},
21570 { (char *)"new_RegionFromBitmap", (PyCFunction) _wrap_new_RegionFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21571 { (char *)"new_RegionFromBitmapColour", (PyCFunction) _wrap_new_RegionFromBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
21572 { (char *)"new_RegionFromPoints", (PyCFunction) _wrap_new_RegionFromPoints, METH_VARARGS | METH_KEYWORDS, NULL},
21573 { (char *)"delete_Region", (PyCFunction) _wrap_delete_Region, METH_VARARGS | METH_KEYWORDS, NULL},
21574 { (char *)"Region_Clear", (PyCFunction) _wrap_Region_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
21575 { (char *)"Region_Offset", (PyCFunction) _wrap_Region_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
21576 { (char *)"Region_Contains", (PyCFunction) _wrap_Region_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
21577 { (char *)"Region_ContainsPoint", (PyCFunction) _wrap_Region_ContainsPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21578 { (char *)"Region_ContainsRect", (PyCFunction) _wrap_Region_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
21579 { (char *)"Region_ContainsRectDim", (PyCFunction) _wrap_Region_ContainsRectDim, METH_VARARGS | METH_KEYWORDS, NULL},
21580 { (char *)"Region_GetBox", (PyCFunction) _wrap_Region_GetBox, METH_VARARGS | METH_KEYWORDS, NULL},
21581 { (char *)"Region_Intersect", (PyCFunction) _wrap_Region_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
21582 { (char *)"Region_IntersectRect", (PyCFunction) _wrap_Region_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
21583 { (char *)"Region_IntersectRegion", (PyCFunction) _wrap_Region_IntersectRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21584 { (char *)"Region_IsEmpty", (PyCFunction) _wrap_Region_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
21585 { (char *)"Region_Union", (PyCFunction) _wrap_Region_Union, METH_VARARGS | METH_KEYWORDS, NULL},
21586 { (char *)"Region_UnionRect", (PyCFunction) _wrap_Region_UnionRect, METH_VARARGS | METH_KEYWORDS, NULL},
21587 { (char *)"Region_UnionRegion", (PyCFunction) _wrap_Region_UnionRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21588 { (char *)"Region_Subtract", (PyCFunction) _wrap_Region_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
21589 { (char *)"Region_SubtractRect", (PyCFunction) _wrap_Region_SubtractRect, METH_VARARGS | METH_KEYWORDS, NULL},
21590 { (char *)"Region_SubtractRegion", (PyCFunction) _wrap_Region_SubtractRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21591 { (char *)"Region_Xor", (PyCFunction) _wrap_Region_Xor, METH_VARARGS | METH_KEYWORDS, NULL},
21592 { (char *)"Region_XorRect", (PyCFunction) _wrap_Region_XorRect, METH_VARARGS | METH_KEYWORDS, NULL},
21593 { (char *)"Region_XorRegion", (PyCFunction) _wrap_Region_XorRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21594 { (char *)"Region_ConvertToBitmap", (PyCFunction) _wrap_Region_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21595 { (char *)"Region_UnionBitmap", (PyCFunction) _wrap_Region_UnionBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21596 { (char *)"Region_UnionBitmapColour", (PyCFunction) _wrap_Region_UnionBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
21597 { (char *)"Region_swigregister", Region_swigregister, METH_VARARGS, NULL},
21598 { (char *)"new_RegionIterator", (PyCFunction) _wrap_new_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
21599 { (char *)"delete_RegionIterator", (PyCFunction) _wrap_delete_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
21600 { (char *)"RegionIterator_GetX", (PyCFunction) _wrap_RegionIterator_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
21601 { (char *)"RegionIterator_GetY", (PyCFunction) _wrap_RegionIterator_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
21602 { (char *)"RegionIterator_GetW", (PyCFunction) _wrap_RegionIterator_GetW, METH_VARARGS | METH_KEYWORDS, NULL},
21603 { (char *)"RegionIterator_GetWidth", (PyCFunction) _wrap_RegionIterator_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21604 { (char *)"RegionIterator_GetH", (PyCFunction) _wrap_RegionIterator_GetH, METH_VARARGS | METH_KEYWORDS, NULL},
21605 { (char *)"RegionIterator_GetHeight", (PyCFunction) _wrap_RegionIterator_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21606 { (char *)"RegionIterator_GetRect", (PyCFunction) _wrap_RegionIterator_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
21607 { (char *)"RegionIterator_HaveRects", (PyCFunction) _wrap_RegionIterator_HaveRects, METH_VARARGS | METH_KEYWORDS, NULL},
21608 { (char *)"RegionIterator_Reset", (PyCFunction) _wrap_RegionIterator_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
21609 { (char *)"RegionIterator_Next", (PyCFunction) _wrap_RegionIterator_Next, METH_VARARGS | METH_KEYWORDS, NULL},
21610 { (char *)"RegionIterator___nonzero__", (PyCFunction) _wrap_RegionIterator___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
21611 { (char *)"RegionIterator_swigregister", RegionIterator_swigregister, METH_VARARGS, NULL},
21612 { (char *)"new_NativeFontInfo", (PyCFunction) _wrap_new_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21613 { (char *)"delete_NativeFontInfo", (PyCFunction) _wrap_delete_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21614 { (char *)"NativeFontInfo_Init", (PyCFunction) _wrap_NativeFontInfo_Init, METH_VARARGS | METH_KEYWORDS, NULL},
21615 { (char *)"NativeFontInfo_InitFromFont", (PyCFunction) _wrap_NativeFontInfo_InitFromFont, METH_VARARGS | METH_KEYWORDS, NULL},
21616 { (char *)"NativeFontInfo_GetPointSize", (PyCFunction) _wrap_NativeFontInfo_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21617 { (char *)"NativeFontInfo_GetPixelSize", (PyCFunction) _wrap_NativeFontInfo_GetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21618 { (char *)"NativeFontInfo_GetStyle", (PyCFunction) _wrap_NativeFontInfo_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21619 { (char *)"NativeFontInfo_GetWeight", (PyCFunction) _wrap_NativeFontInfo_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21620 { (char *)"NativeFontInfo_GetUnderlined", (PyCFunction) _wrap_NativeFontInfo_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21621 { (char *)"NativeFontInfo_GetFaceName", (PyCFunction) _wrap_NativeFontInfo_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21622 { (char *)"NativeFontInfo_GetFamily", (PyCFunction) _wrap_NativeFontInfo_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21623 { (char *)"NativeFontInfo_GetEncoding", (PyCFunction) _wrap_NativeFontInfo_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21624 { (char *)"NativeFontInfo_SetPointSize", (PyCFunction) _wrap_NativeFontInfo_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21625 { (char *)"NativeFontInfo_SetPixelSize", (PyCFunction) _wrap_NativeFontInfo_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21626 { (char *)"NativeFontInfo_SetStyle", (PyCFunction) _wrap_NativeFontInfo_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21627 { (char *)"NativeFontInfo_SetWeight", (PyCFunction) _wrap_NativeFontInfo_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21628 { (char *)"NativeFontInfo_SetUnderlined", (PyCFunction) _wrap_NativeFontInfo_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21629 { (char *)"NativeFontInfo_SetFaceName", (PyCFunction) _wrap_NativeFontInfo_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21630 { (char *)"NativeFontInfo_SetFamily", (PyCFunction) _wrap_NativeFontInfo_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21631 { (char *)"NativeFontInfo_SetEncoding", (PyCFunction) _wrap_NativeFontInfo_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21632 { (char *)"NativeFontInfo_FromString", (PyCFunction) _wrap_NativeFontInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
21633 { (char *)"NativeFontInfo_ToString", (PyCFunction) _wrap_NativeFontInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
21634 { (char *)"NativeFontInfo___str__", (PyCFunction) _wrap_NativeFontInfo___str__, METH_VARARGS | METH_KEYWORDS, NULL},
21635 { (char *)"NativeFontInfo_FromUserString", (PyCFunction) _wrap_NativeFontInfo_FromUserString, METH_VARARGS | METH_KEYWORDS, NULL},
21636 { (char *)"NativeFontInfo_ToUserString", (PyCFunction) _wrap_NativeFontInfo_ToUserString, METH_VARARGS | METH_KEYWORDS, NULL},
21637 { (char *)"NativeFontInfo_swigregister", NativeFontInfo_swigregister, METH_VARARGS, NULL},
21638 { (char *)"NativeEncodingInfo_facename_set", (PyCFunction) _wrap_NativeEncodingInfo_facename_set, METH_VARARGS | METH_KEYWORDS, NULL},
21639 { (char *)"NativeEncodingInfo_facename_get", (PyCFunction) _wrap_NativeEncodingInfo_facename_get, METH_VARARGS | METH_KEYWORDS, NULL},
21640 { (char *)"NativeEncodingInfo_encoding_set", (PyCFunction) _wrap_NativeEncodingInfo_encoding_set, METH_VARARGS | METH_KEYWORDS, NULL},
21641 { (char *)"NativeEncodingInfo_encoding_get", (PyCFunction) _wrap_NativeEncodingInfo_encoding_get, METH_VARARGS | METH_KEYWORDS, NULL},
21642 { (char *)"new_NativeEncodingInfo", (PyCFunction) _wrap_new_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21643 { (char *)"delete_NativeEncodingInfo", (PyCFunction) _wrap_delete_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21644 { (char *)"NativeEncodingInfo_FromString", (PyCFunction) _wrap_NativeEncodingInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
21645 { (char *)"NativeEncodingInfo_ToString", (PyCFunction) _wrap_NativeEncodingInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
21646 { (char *)"NativeEncodingInfo_swigregister", NativeEncodingInfo_swigregister, METH_VARARGS, NULL},
21647 { (char *)"GetNativeFontEncoding", (PyCFunction) _wrap_GetNativeFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21648 { (char *)"TestFontEncoding", (PyCFunction) _wrap_TestFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21649 { (char *)"new_FontMapper", (PyCFunction) _wrap_new_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
21650 { (char *)"delete_FontMapper", (PyCFunction) _wrap_delete_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
21651 { (char *)"FontMapper_Get", (PyCFunction) _wrap_FontMapper_Get, METH_VARARGS | METH_KEYWORDS, NULL},
21652 { (char *)"FontMapper_Set", (PyCFunction) _wrap_FontMapper_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21653 { (char *)"FontMapper_CharsetToEncoding", (PyCFunction) _wrap_FontMapper_CharsetToEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21654 { (char *)"FontMapper_GetSupportedEncodingsCount", (PyCFunction) _wrap_FontMapper_GetSupportedEncodingsCount, METH_VARARGS | METH_KEYWORDS, NULL},
21655 { (char *)"FontMapper_GetEncoding", (PyCFunction) _wrap_FontMapper_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21656 { (char *)"FontMapper_GetEncodingName", (PyCFunction) _wrap_FontMapper_GetEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
21657 { (char *)"FontMapper_GetEncodingDescription", (PyCFunction) _wrap_FontMapper_GetEncodingDescription, METH_VARARGS | METH_KEYWORDS, NULL},
21658 { (char *)"FontMapper_GetEncodingFromName", (PyCFunction) _wrap_FontMapper_GetEncodingFromName, METH_VARARGS | METH_KEYWORDS, NULL},
21659 { (char *)"FontMapper_SetConfig", (PyCFunction) _wrap_FontMapper_SetConfig, METH_VARARGS | METH_KEYWORDS, NULL},
21660 { (char *)"FontMapper_SetConfigPath", (PyCFunction) _wrap_FontMapper_SetConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
21661 { (char *)"FontMapper_GetDefaultConfigPath", (PyCFunction) _wrap_FontMapper_GetDefaultConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
21662 { (char *)"FontMapper_GetAltForEncoding", (PyCFunction) _wrap_FontMapper_GetAltForEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21663 { (char *)"FontMapper_IsEncodingAvailable", (PyCFunction) _wrap_FontMapper_IsEncodingAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
21664 { (char *)"FontMapper_SetDialogParent", (PyCFunction) _wrap_FontMapper_SetDialogParent, METH_VARARGS | METH_KEYWORDS, NULL},
21665 { (char *)"FontMapper_SetDialogTitle", (PyCFunction) _wrap_FontMapper_SetDialogTitle, METH_VARARGS | METH_KEYWORDS, NULL},
21666 { (char *)"FontMapper_swigregister", FontMapper_swigregister, METH_VARARGS, NULL},
21667 { (char *)"new_Font", (PyCFunction) _wrap_new_Font, METH_VARARGS | METH_KEYWORDS, NULL},
21668 { (char *)"delete_Font", (PyCFunction) _wrap_delete_Font, METH_VARARGS | METH_KEYWORDS, NULL},
21669 { (char *)"new_FontFromNativeInfo", (PyCFunction) _wrap_new_FontFromNativeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21670 { (char *)"new_FontFromNativeInfoString", (PyCFunction) _wrap_new_FontFromNativeInfoString, METH_VARARGS | METH_KEYWORDS, NULL},
21671 { (char *)"new_Font2", (PyCFunction) _wrap_new_Font2, METH_VARARGS | METH_KEYWORDS, NULL},
21672 { (char *)"new_FontFromPixelSize", (PyCFunction) _wrap_new_FontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21673 { (char *)"Font_Ok", (PyCFunction) _wrap_Font_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21674 { (char *)"Font___eq__", (PyCFunction) _wrap_Font___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21675 { (char *)"Font___ne__", (PyCFunction) _wrap_Font___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21676 { (char *)"Font_GetPointSize", (PyCFunction) _wrap_Font_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21677 { (char *)"Font_GetPixelSize", (PyCFunction) _wrap_Font_GetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21678 { (char *)"Font_IsUsingSizeInPixels", (PyCFunction) _wrap_Font_IsUsingSizeInPixels, METH_VARARGS | METH_KEYWORDS, NULL},
21679 { (char *)"Font_GetFamily", (PyCFunction) _wrap_Font_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21680 { (char *)"Font_GetStyle", (PyCFunction) _wrap_Font_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21681 { (char *)"Font_GetWeight", (PyCFunction) _wrap_Font_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21682 { (char *)"Font_GetUnderlined", (PyCFunction) _wrap_Font_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21683 { (char *)"Font_GetFaceName", (PyCFunction) _wrap_Font_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21684 { (char *)"Font_GetEncoding", (PyCFunction) _wrap_Font_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21685 { (char *)"Font_GetNativeFontInfo", (PyCFunction) _wrap_Font_GetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21686 { (char *)"Font_IsFixedWidth", (PyCFunction) _wrap_Font_IsFixedWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21687 { (char *)"Font_GetNativeFontInfoDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoDesc, METH_VARARGS | METH_KEYWORDS, NULL},
21688 { (char *)"Font_GetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
21689 { (char *)"Font_SetPointSize", (PyCFunction) _wrap_Font_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21690 { (char *)"Font_SetPixelSize", (PyCFunction) _wrap_Font_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21691 { (char *)"Font_SetFamily", (PyCFunction) _wrap_Font_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21692 { (char *)"Font_SetStyle", (PyCFunction) _wrap_Font_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21693 { (char *)"Font_SetWeight", (PyCFunction) _wrap_Font_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21694 { (char *)"Font_SetFaceName", (PyCFunction) _wrap_Font_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21695 { (char *)"Font_SetUnderlined", (PyCFunction) _wrap_Font_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21696 { (char *)"Font_SetEncoding", (PyCFunction) _wrap_Font_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21697 { (char *)"Font_SetNativeFontInfo", (PyCFunction) _wrap_Font_SetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21698 { (char *)"Font_SetNativeFontInfoFromString", (PyCFunction) _wrap_Font_SetNativeFontInfoFromString, METH_VARARGS | METH_KEYWORDS, NULL},
21699 { (char *)"Font_SetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_SetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
21700 { (char *)"Font_GetFamilyString", (PyCFunction) _wrap_Font_GetFamilyString, METH_VARARGS | METH_KEYWORDS, NULL},
21701 { (char *)"Font_GetStyleString", (PyCFunction) _wrap_Font_GetStyleString, METH_VARARGS | METH_KEYWORDS, NULL},
21702 { (char *)"Font_GetWeightString", (PyCFunction) _wrap_Font_GetWeightString, METH_VARARGS | METH_KEYWORDS, NULL},
21703 { (char *)"Font_SetNoAntiAliasing", (PyCFunction) _wrap_Font_SetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
21704 { (char *)"Font_GetNoAntiAliasing", (PyCFunction) _wrap_Font_GetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
21705 { (char *)"Font_GetDefaultEncoding", (PyCFunction) _wrap_Font_GetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21706 { (char *)"Font_SetDefaultEncoding", (PyCFunction) _wrap_Font_SetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21707 { (char *)"Font_swigregister", Font_swigregister, METH_VARARGS, NULL},
21708 { (char *)"new_FontEnumerator", (PyCFunction) _wrap_new_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
21709 { (char *)"delete_FontEnumerator", (PyCFunction) _wrap_delete_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
21710 { (char *)"FontEnumerator__setCallbackInfo", (PyCFunction) _wrap_FontEnumerator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21711 { (char *)"FontEnumerator_EnumerateFacenames", (PyCFunction) _wrap_FontEnumerator_EnumerateFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
21712 { (char *)"FontEnumerator_EnumerateEncodings", (PyCFunction) _wrap_FontEnumerator_EnumerateEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
21713 { (char *)"FontEnumerator_GetEncodings", (PyCFunction) _wrap_FontEnumerator_GetEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
21714 { (char *)"FontEnumerator_GetFacenames", (PyCFunction) _wrap_FontEnumerator_GetFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
21715 { (char *)"FontEnumerator_swigregister", FontEnumerator_swigregister, METH_VARARGS, NULL},
21716 { (char *)"LanguageInfo_Language_set", (PyCFunction) _wrap_LanguageInfo_Language_set, METH_VARARGS | METH_KEYWORDS, NULL},
21717 { (char *)"LanguageInfo_Language_get", (PyCFunction) _wrap_LanguageInfo_Language_get, METH_VARARGS | METH_KEYWORDS, NULL},
21718 { (char *)"LanguageInfo_CanonicalName_set", (PyCFunction) _wrap_LanguageInfo_CanonicalName_set, METH_VARARGS | METH_KEYWORDS, NULL},
21719 { (char *)"LanguageInfo_CanonicalName_get", (PyCFunction) _wrap_LanguageInfo_CanonicalName_get, METH_VARARGS | METH_KEYWORDS, NULL},
21720 { (char *)"LanguageInfo_Description_set", (PyCFunction) _wrap_LanguageInfo_Description_set, METH_VARARGS | METH_KEYWORDS, NULL},
21721 { (char *)"LanguageInfo_Description_get", (PyCFunction) _wrap_LanguageInfo_Description_get, METH_VARARGS | METH_KEYWORDS, NULL},
21722 { (char *)"LanguageInfo_swigregister", LanguageInfo_swigregister, METH_VARARGS, NULL},
21723 { (char *)"new_Locale", (PyCFunction) _wrap_new_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
21724 { (char *)"delete_Locale", (PyCFunction) _wrap_delete_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
21725 { (char *)"Locale_Init1", (PyCFunction) _wrap_Locale_Init1, METH_VARARGS | METH_KEYWORDS, NULL},
21726 { (char *)"Locale_Init2", (PyCFunction) _wrap_Locale_Init2, METH_VARARGS | METH_KEYWORDS, NULL},
21727 { (char *)"Locale_GetSystemLanguage", (PyCFunction) _wrap_Locale_GetSystemLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
21728 { (char *)"Locale_GetSystemEncoding", (PyCFunction) _wrap_Locale_GetSystemEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21729 { (char *)"Locale_GetSystemEncodingName", (PyCFunction) _wrap_Locale_GetSystemEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
21730 { (char *)"Locale_IsOk", (PyCFunction) _wrap_Locale_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
21731 { (char *)"Locale_GetLocale", (PyCFunction) _wrap_Locale_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
21732 { (char *)"Locale_GetLanguage", (PyCFunction) _wrap_Locale_GetLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
21733 { (char *)"Locale_GetSysName", (PyCFunction) _wrap_Locale_GetSysName, METH_VARARGS | METH_KEYWORDS, NULL},
21734 { (char *)"Locale_GetCanonicalName", (PyCFunction) _wrap_Locale_GetCanonicalName, METH_VARARGS | METH_KEYWORDS, NULL},
21735 { (char *)"Locale_AddCatalogLookupPathPrefix", (PyCFunction) _wrap_Locale_AddCatalogLookupPathPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
21736 { (char *)"Locale_AddCatalog", (PyCFunction) _wrap_Locale_AddCatalog, METH_VARARGS | METH_KEYWORDS, NULL},
21737 { (char *)"Locale_IsLoaded", (PyCFunction) _wrap_Locale_IsLoaded, METH_VARARGS | METH_KEYWORDS, NULL},
21738 { (char *)"Locale_GetLanguageInfo", (PyCFunction) _wrap_Locale_GetLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21739 { (char *)"Locale_GetLanguageName", (PyCFunction) _wrap_Locale_GetLanguageName, METH_VARARGS | METH_KEYWORDS, NULL},
21740 { (char *)"Locale_FindLanguageInfo", (PyCFunction) _wrap_Locale_FindLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21741 { (char *)"Locale_AddLanguage", (PyCFunction) _wrap_Locale_AddLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
21742 { (char *)"Locale_GetString", (PyCFunction) _wrap_Locale_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
21743 { (char *)"Locale_GetName", (PyCFunction) _wrap_Locale_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
21744 { (char *)"Locale_swigregister", Locale_swigregister, METH_VARARGS, NULL},
21745 { (char *)"GetLocale", (PyCFunction) _wrap_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
21746 { (char *)"GetTranslation", _wrap_GetTranslation, METH_VARARGS, NULL},
21747 { (char *)"new_EncodingConverter", (PyCFunction) _wrap_new_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
21748 { (char *)"delete_EncodingConverter", (PyCFunction) _wrap_delete_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
21749 { (char *)"EncodingConverter_Init", (PyCFunction) _wrap_EncodingConverter_Init, METH_VARARGS | METH_KEYWORDS, NULL},
21750 { (char *)"EncodingConverter_Convert", (PyCFunction) _wrap_EncodingConverter_Convert, METH_VARARGS | METH_KEYWORDS, NULL},
21751 { (char *)"EncodingConverter_GetPlatformEquivalents", (PyCFunction) _wrap_EncodingConverter_GetPlatformEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
21752 { (char *)"EncodingConverter_GetAllEquivalents", (PyCFunction) _wrap_EncodingConverter_GetAllEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
21753 { (char *)"EncodingConverter_CanConvert", (PyCFunction) _wrap_EncodingConverter_CanConvert, METH_VARARGS | METH_KEYWORDS, NULL},
21754 { (char *)"EncodingConverter_swigregister", EncodingConverter_swigregister, METH_VARARGS, NULL},
21755 { (char *)"delete_DC", (PyCFunction) _wrap_delete_DC, METH_VARARGS | METH_KEYWORDS, NULL},
21756 { (char *)"DC_BeginDrawing", (PyCFunction) _wrap_DC_BeginDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
21757 { (char *)"DC_EndDrawing", (PyCFunction) _wrap_DC_EndDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
21758 { (char *)"DC_FloodFill", (PyCFunction) _wrap_DC_FloodFill, METH_VARARGS | METH_KEYWORDS, NULL},
21759 { (char *)"DC_FloodFillPoint", (PyCFunction) _wrap_DC_FloodFillPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21760 { (char *)"DC_GetPixel", (PyCFunction) _wrap_DC_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
21761 { (char *)"DC_GetPixelPoint", (PyCFunction) _wrap_DC_GetPixelPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21762 { (char *)"DC_DrawLine", (PyCFunction) _wrap_DC_DrawLine, METH_VARARGS | METH_KEYWORDS, NULL},
21763 { (char *)"DC_DrawLinePoint", (PyCFunction) _wrap_DC_DrawLinePoint, METH_VARARGS | METH_KEYWORDS, NULL},
21764 { (char *)"DC_CrossHair", (PyCFunction) _wrap_DC_CrossHair, METH_VARARGS | METH_KEYWORDS, NULL},
21765 { (char *)"DC_CrossHairPoint", (PyCFunction) _wrap_DC_CrossHairPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21766 { (char *)"DC_DrawArc", (PyCFunction) _wrap_DC_DrawArc, METH_VARARGS | METH_KEYWORDS, NULL},
21767 { (char *)"DC_DrawArcPoint", (PyCFunction) _wrap_DC_DrawArcPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21768 { (char *)"DC_DrawCheckMark", (PyCFunction) _wrap_DC_DrawCheckMark, METH_VARARGS | METH_KEYWORDS, NULL},
21769 { (char *)"DC_DrawCheckMarkRect", (PyCFunction) _wrap_DC_DrawCheckMarkRect, METH_VARARGS | METH_KEYWORDS, NULL},
21770 { (char *)"DC_DrawEllipticArc", (PyCFunction) _wrap_DC_DrawEllipticArc, METH_VARARGS | METH_KEYWORDS, NULL},
21771 { (char *)"DC_DrawEllipticArcPointSize", (PyCFunction) _wrap_DC_DrawEllipticArcPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21772 { (char *)"DC_DrawPoint", (PyCFunction) _wrap_DC_DrawPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21773 { (char *)"DC_DrawPointPoint", (PyCFunction) _wrap_DC_DrawPointPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21774 { (char *)"DC_DrawRectangle", (PyCFunction) _wrap_DC_DrawRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
21775 { (char *)"DC_DrawRectangleRect", (PyCFunction) _wrap_DC_DrawRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
21776 { (char *)"DC_DrawRectanglePointSize", (PyCFunction) _wrap_DC_DrawRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21777 { (char *)"DC_DrawRoundedRectangle", (PyCFunction) _wrap_DC_DrawRoundedRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
21778 { (char *)"DC_DrawRoundedRectangleRect", (PyCFunction) _wrap_DC_DrawRoundedRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
21779 { (char *)"DC_DrawRoundedRectanglePointSize", (PyCFunction) _wrap_DC_DrawRoundedRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21780 { (char *)"DC_DrawCircle", (PyCFunction) _wrap_DC_DrawCircle, METH_VARARGS | METH_KEYWORDS, NULL},
21781 { (char *)"DC_DrawCirclePoint", (PyCFunction) _wrap_DC_DrawCirclePoint, METH_VARARGS | METH_KEYWORDS, NULL},
21782 { (char *)"DC_DrawEllipse", (PyCFunction) _wrap_DC_DrawEllipse, METH_VARARGS | METH_KEYWORDS, NULL},
21783 { (char *)"DC_DrawEllipseRect", (PyCFunction) _wrap_DC_DrawEllipseRect, METH_VARARGS | METH_KEYWORDS, NULL},
21784 { (char *)"DC_DrawEllipsePointSize", (PyCFunction) _wrap_DC_DrawEllipsePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21785 { (char *)"DC_DrawIcon", (PyCFunction) _wrap_DC_DrawIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21786 { (char *)"DC_DrawIconPoint", (PyCFunction) _wrap_DC_DrawIconPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21787 { (char *)"DC_DrawBitmap", (PyCFunction) _wrap_DC_DrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21788 { (char *)"DC_DrawBitmapPoint", (PyCFunction) _wrap_DC_DrawBitmapPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21789 { (char *)"DC_DrawText", (PyCFunction) _wrap_DC_DrawText, METH_VARARGS | METH_KEYWORDS, NULL},
21790 { (char *)"DC_DrawTextPoint", (PyCFunction) _wrap_DC_DrawTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21791 { (char *)"DC_DrawRotatedText", (PyCFunction) _wrap_DC_DrawRotatedText, METH_VARARGS | METH_KEYWORDS, NULL},
21792 { (char *)"DC_DrawRotatedTextPoint", (PyCFunction) _wrap_DC_DrawRotatedTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21793 { (char *)"DC_Blit", (PyCFunction) _wrap_DC_Blit, METH_VARARGS | METH_KEYWORDS, NULL},
21794 { (char *)"DC_BlitPointSize", (PyCFunction) _wrap_DC_BlitPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21795 { (char *)"DC_SetClippingRegion", (PyCFunction) _wrap_DC_SetClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21796 { (char *)"DC_SetClippingRegionPointSize", (PyCFunction) _wrap_DC_SetClippingRegionPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21797 { (char *)"DC_SetClippingRegionAsRegion", (PyCFunction) _wrap_DC_SetClippingRegionAsRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21798 { (char *)"DC_SetClippingRect", (PyCFunction) _wrap_DC_SetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
21799 { (char *)"DC_DrawLines", (PyCFunction) _wrap_DC_DrawLines, METH_VARARGS | METH_KEYWORDS, NULL},
21800 { (char *)"DC_DrawPolygon", (PyCFunction) _wrap_DC_DrawPolygon, METH_VARARGS | METH_KEYWORDS, NULL},
21801 { (char *)"DC_DrawLabel", (PyCFunction) _wrap_DC_DrawLabel, METH_VARARGS | METH_KEYWORDS, NULL},
21802 { (char *)"DC_DrawImageLabel", (PyCFunction) _wrap_DC_DrawImageLabel, METH_VARARGS | METH_KEYWORDS, NULL},
21803 { (char *)"DC_DrawSpline", (PyCFunction) _wrap_DC_DrawSpline, METH_VARARGS | METH_KEYWORDS, NULL},
21804 { (char *)"DC_Clear", (PyCFunction) _wrap_DC_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
21805 { (char *)"DC_StartDoc", (PyCFunction) _wrap_DC_StartDoc, METH_VARARGS | METH_KEYWORDS, NULL},
21806 { (char *)"DC_EndDoc", (PyCFunction) _wrap_DC_EndDoc, METH_VARARGS | METH_KEYWORDS, NULL},
21807 { (char *)"DC_StartPage", (PyCFunction) _wrap_DC_StartPage, METH_VARARGS | METH_KEYWORDS, NULL},
21808 { (char *)"DC_EndPage", (PyCFunction) _wrap_DC_EndPage, METH_VARARGS | METH_KEYWORDS, NULL},
21809 { (char *)"DC_SetFont", (PyCFunction) _wrap_DC_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
21810 { (char *)"DC_SetPen", (PyCFunction) _wrap_DC_SetPen, METH_VARARGS | METH_KEYWORDS, NULL},
21811 { (char *)"DC_SetBrush", (PyCFunction) _wrap_DC_SetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21812 { (char *)"DC_SetBackground", (PyCFunction) _wrap_DC_SetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21813 { (char *)"DC_SetBackgroundMode", (PyCFunction) _wrap_DC_SetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
21814 { (char *)"DC_SetPalette", (PyCFunction) _wrap_DC_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
21815 { (char *)"DC_DestroyClippingRegion", (PyCFunction) _wrap_DC_DestroyClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21816 { (char *)"DC_GetClippingBox", (PyCFunction) _wrap_DC_GetClippingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21817 { (char *)"DC_GetClippingRect", (PyCFunction) _wrap_DC_GetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
21818 { (char *)"DC_GetCharHeight", (PyCFunction) _wrap_DC_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21819 { (char *)"DC_GetCharWidth", (PyCFunction) _wrap_DC_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21820 { (char *)"DC_GetTextExtent", (PyCFunction) _wrap_DC_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21821 { (char *)"DC_GetFullTextExtent", (PyCFunction) _wrap_DC_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21822 { (char *)"DC_GetMultiLineTextExtent", (PyCFunction) _wrap_DC_GetMultiLineTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21823 { (char *)"DC_GetPartialTextExtents", (PyCFunction) _wrap_DC_GetPartialTextExtents, METH_VARARGS | METH_KEYWORDS, NULL},
21824 { (char *)"DC_GetSize", (PyCFunction) _wrap_DC_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21825 { (char *)"DC_GetSizeTuple", (PyCFunction) _wrap_DC_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21826 { (char *)"DC_GetSizeMM", (PyCFunction) _wrap_DC_GetSizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
21827 { (char *)"DC_GetSizeMMTuple", (PyCFunction) _wrap_DC_GetSizeMMTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21828 { (char *)"DC_DeviceToLogicalX", (PyCFunction) _wrap_DC_DeviceToLogicalX, METH_VARARGS | METH_KEYWORDS, NULL},
21829 { (char *)"DC_DeviceToLogicalY", (PyCFunction) _wrap_DC_DeviceToLogicalY, METH_VARARGS | METH_KEYWORDS, NULL},
21830 { (char *)"DC_DeviceToLogicalXRel", (PyCFunction) _wrap_DC_DeviceToLogicalXRel, METH_VARARGS | METH_KEYWORDS, NULL},
21831 { (char *)"DC_DeviceToLogicalYRel", (PyCFunction) _wrap_DC_DeviceToLogicalYRel, METH_VARARGS | METH_KEYWORDS, NULL},
21832 { (char *)"DC_LogicalToDeviceX", (PyCFunction) _wrap_DC_LogicalToDeviceX, METH_VARARGS | METH_KEYWORDS, NULL},
21833 { (char *)"DC_LogicalToDeviceY", (PyCFunction) _wrap_DC_LogicalToDeviceY, METH_VARARGS | METH_KEYWORDS, NULL},
21834 { (char *)"DC_LogicalToDeviceXRel", (PyCFunction) _wrap_DC_LogicalToDeviceXRel, METH_VARARGS | METH_KEYWORDS, NULL},
21835 { (char *)"DC_LogicalToDeviceYRel", (PyCFunction) _wrap_DC_LogicalToDeviceYRel, METH_VARARGS | METH_KEYWORDS, NULL},
21836 { (char *)"DC_CanDrawBitmap", (PyCFunction) _wrap_DC_CanDrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21837 { (char *)"DC_CanGetTextExtent", (PyCFunction) _wrap_DC_CanGetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21838 { (char *)"DC_GetDepth", (PyCFunction) _wrap_DC_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21839 { (char *)"DC_GetPPI", (PyCFunction) _wrap_DC_GetPPI, METH_VARARGS | METH_KEYWORDS, NULL},
21840 { (char *)"DC_Ok", (PyCFunction) _wrap_DC_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21841 { (char *)"DC_GetBackgroundMode", (PyCFunction) _wrap_DC_GetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
21842 { (char *)"DC_GetBackground", (PyCFunction) _wrap_DC_GetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21843 { (char *)"DC_GetBrush", (PyCFunction) _wrap_DC_GetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21844 { (char *)"DC_GetFont", (PyCFunction) _wrap_DC_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
21845 { (char *)"DC_GetPen", (PyCFunction) _wrap_DC_GetPen, METH_VARARGS | METH_KEYWORDS, NULL},
21846 { (char *)"DC_GetTextBackground", (PyCFunction) _wrap_DC_GetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21847 { (char *)"DC_GetTextForeground", (PyCFunction) _wrap_DC_GetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
21848 { (char *)"DC_SetTextForeground", (PyCFunction) _wrap_DC_SetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
21849 { (char *)"DC_SetTextBackground", (PyCFunction) _wrap_DC_SetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21850 { (char *)"DC_GetMapMode", (PyCFunction) _wrap_DC_GetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
21851 { (char *)"DC_SetMapMode", (PyCFunction) _wrap_DC_SetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
21852 { (char *)"DC_GetUserScale", (PyCFunction) _wrap_DC_GetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
21853 { (char *)"DC_SetUserScale", (PyCFunction) _wrap_DC_SetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
21854 { (char *)"DC_GetLogicalScale", (PyCFunction) _wrap_DC_GetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
21855 { (char *)"DC_SetLogicalScale", (PyCFunction) _wrap_DC_SetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
21856 { (char *)"DC_GetLogicalOrigin", (PyCFunction) _wrap_DC_GetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21857 { (char *)"DC_GetLogicalOriginTuple", (PyCFunction) _wrap_DC_GetLogicalOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21858 { (char *)"DC_SetLogicalOrigin", (PyCFunction) _wrap_DC_SetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21859 { (char *)"DC_SetLogicalOriginPoint", (PyCFunction) _wrap_DC_SetLogicalOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21860 { (char *)"DC_GetDeviceOrigin", (PyCFunction) _wrap_DC_GetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21861 { (char *)"DC_GetDeviceOriginTuple", (PyCFunction) _wrap_DC_GetDeviceOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21862 { (char *)"DC_SetDeviceOrigin", (PyCFunction) _wrap_DC_SetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21863 { (char *)"DC_SetDeviceOriginPoint", (PyCFunction) _wrap_DC_SetDeviceOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21864 { (char *)"DC_SetAxisOrientation", (PyCFunction) _wrap_DC_SetAxisOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
21865 { (char *)"DC_GetLogicalFunction", (PyCFunction) _wrap_DC_GetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
21866 { (char *)"DC_SetLogicalFunction", (PyCFunction) _wrap_DC_SetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
21867 { (char *)"DC_ComputeScaleAndOrigin", (PyCFunction) _wrap_DC_ComputeScaleAndOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21868 { (char *)"DC_CalcBoundingBox", (PyCFunction) _wrap_DC_CalcBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21869 { (char *)"DC_CalcBoundingBoxPoint", (PyCFunction) _wrap_DC_CalcBoundingBoxPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21870 { (char *)"DC_ResetBoundingBox", (PyCFunction) _wrap_DC_ResetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21871 { (char *)"DC_MinX", (PyCFunction) _wrap_DC_MinX, METH_VARARGS | METH_KEYWORDS, NULL},
21872 { (char *)"DC_MaxX", (PyCFunction) _wrap_DC_MaxX, METH_VARARGS | METH_KEYWORDS, NULL},
21873 { (char *)"DC_MinY", (PyCFunction) _wrap_DC_MinY, METH_VARARGS | METH_KEYWORDS, NULL},
21874 { (char *)"DC_MaxY", (PyCFunction) _wrap_DC_MaxY, METH_VARARGS | METH_KEYWORDS, NULL},
21875 { (char *)"DC_GetBoundingBox", (PyCFunction) _wrap_DC_GetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21876 { (char *)"DC_GetHDC", (PyCFunction) _wrap_DC_GetHDC, METH_VARARGS | METH_KEYWORDS, NULL},
21877 { (char *)"DC__DrawPointList", (PyCFunction) _wrap_DC__DrawPointList, METH_VARARGS | METH_KEYWORDS, NULL},
21878 { (char *)"DC__DrawLineList", (PyCFunction) _wrap_DC__DrawLineList, METH_VARARGS | METH_KEYWORDS, NULL},
21879 { (char *)"DC__DrawRectangleList", (PyCFunction) _wrap_DC__DrawRectangleList, METH_VARARGS | METH_KEYWORDS, NULL},
21880 { (char *)"DC__DrawEllipseList", (PyCFunction) _wrap_DC__DrawEllipseList, METH_VARARGS | METH_KEYWORDS, NULL},
21881 { (char *)"DC__DrawPolygonList", (PyCFunction) _wrap_DC__DrawPolygonList, METH_VARARGS | METH_KEYWORDS, NULL},
21882 { (char *)"DC__DrawTextList", (PyCFunction) _wrap_DC__DrawTextList, METH_VARARGS | METH_KEYWORDS, NULL},
21883 { (char *)"DC_swigregister", DC_swigregister, METH_VARARGS, NULL},
21884 { (char *)"new_MemoryDC", (PyCFunction) _wrap_new_MemoryDC, METH_VARARGS | METH_KEYWORDS, NULL},
21885 { (char *)"new_MemoryDCFromDC", (PyCFunction) _wrap_new_MemoryDCFromDC, METH_VARARGS | METH_KEYWORDS, NULL},
21886 { (char *)"MemoryDC_SelectObject", (PyCFunction) _wrap_MemoryDC_SelectObject, METH_VARARGS | METH_KEYWORDS, NULL},
21887 { (char *)"MemoryDC_swigregister", MemoryDC_swigregister, METH_VARARGS, NULL},
21888 { (char *)"new_BufferedDC", _wrap_new_BufferedDC, METH_VARARGS, NULL},
21889 { (char *)"delete_BufferedDC", (PyCFunction) _wrap_delete_BufferedDC, METH_VARARGS | METH_KEYWORDS, NULL},
21890 { (char *)"BufferedDC_UnMask", (PyCFunction) _wrap_BufferedDC_UnMask, METH_VARARGS | METH_KEYWORDS, NULL},
21891 { (char *)"BufferedDC_swigregister", BufferedDC_swigregister, METH_VARARGS, NULL},
21892 { (char *)"new_BufferedPaintDC", (PyCFunction) _wrap_new_BufferedPaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
21893 { (char *)"BufferedPaintDC_swigregister", BufferedPaintDC_swigregister, METH_VARARGS, NULL},
21894 { (char *)"new_ScreenDC", (PyCFunction) _wrap_new_ScreenDC, METH_VARARGS | METH_KEYWORDS, NULL},
21895 { (char *)"ScreenDC_StartDrawingOnTopWin", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTopWin, METH_VARARGS | METH_KEYWORDS, NULL},
21896 { (char *)"ScreenDC_StartDrawingOnTop", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
21897 { (char *)"ScreenDC_EndDrawingOnTop", (PyCFunction) _wrap_ScreenDC_EndDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
21898 { (char *)"ScreenDC_swigregister", ScreenDC_swigregister, METH_VARARGS, NULL},
21899 { (char *)"new_ClientDC", (PyCFunction) _wrap_new_ClientDC, METH_VARARGS | METH_KEYWORDS, NULL},
21900 { (char *)"ClientDC_swigregister", ClientDC_swigregister, METH_VARARGS, NULL},
21901 { (char *)"new_PaintDC", (PyCFunction) _wrap_new_PaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
21902 { (char *)"PaintDC_swigregister", PaintDC_swigregister, METH_VARARGS, NULL},
21903 { (char *)"new_WindowDC", (PyCFunction) _wrap_new_WindowDC, METH_VARARGS | METH_KEYWORDS, NULL},
21904 { (char *)"WindowDC_swigregister", WindowDC_swigregister, METH_VARARGS, NULL},
21905 { (char *)"new_MirrorDC", (PyCFunction) _wrap_new_MirrorDC, METH_VARARGS | METH_KEYWORDS, NULL},
21906 { (char *)"MirrorDC_swigregister", MirrorDC_swigregister, METH_VARARGS, NULL},
21907 { (char *)"new_PostScriptDC", (PyCFunction) _wrap_new_PostScriptDC, METH_VARARGS | METH_KEYWORDS, NULL},
21908 { (char *)"PostScriptDC_GetPrintData", (PyCFunction) _wrap_PostScriptDC_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
21909 { (char *)"PostScriptDC_SetPrintData", (PyCFunction) _wrap_PostScriptDC_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
21910 { (char *)"PostScriptDC_SetResolution", (PyCFunction) _wrap_PostScriptDC_SetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
21911 { (char *)"PostScriptDC_GetResolution", (PyCFunction) _wrap_PostScriptDC_GetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
21912 { (char *)"PostScriptDC_swigregister", PostScriptDC_swigregister, METH_VARARGS, NULL},
21913 { (char *)"new_MetaFile", (PyCFunction) _wrap_new_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
21914 { (char *)"delete_MetaFile", (PyCFunction) _wrap_delete_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
21915 { (char *)"MetaFile_Ok", (PyCFunction) _wrap_MetaFile_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21916 { (char *)"MetaFile_SetClipboard", (PyCFunction) _wrap_MetaFile_SetClipboard, METH_VARARGS | METH_KEYWORDS, NULL},
21917 { (char *)"MetaFile_GetSize", (PyCFunction) _wrap_MetaFile_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21918 { (char *)"MetaFile_GetWidth", (PyCFunction) _wrap_MetaFile_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21919 { (char *)"MetaFile_GetHeight", (PyCFunction) _wrap_MetaFile_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21920 { (char *)"MetaFile_GetFileName", (PyCFunction) _wrap_MetaFile_GetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
21921 { (char *)"MetaFile_swigregister", MetaFile_swigregister, METH_VARARGS, NULL},
21922 { (char *)"new_MetaFileDC", (PyCFunction) _wrap_new_MetaFileDC, METH_VARARGS | METH_KEYWORDS, NULL},
21923 { (char *)"MetaFileDC_Close", (PyCFunction) _wrap_MetaFileDC_Close, METH_VARARGS | METH_KEYWORDS, NULL},
21924 { (char *)"MetaFileDC_swigregister", MetaFileDC_swigregister, METH_VARARGS, NULL},
21925 { (char *)"new_PrinterDC", (PyCFunction) _wrap_new_PrinterDC, METH_VARARGS | METH_KEYWORDS, NULL},
21926 { (char *)"PrinterDC_swigregister", PrinterDC_swigregister, METH_VARARGS, NULL},
21927 { (char *)"new_ImageList", (PyCFunction) _wrap_new_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
21928 { (char *)"delete_ImageList", (PyCFunction) _wrap_delete_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
21929 { (char *)"ImageList_Add", (PyCFunction) _wrap_ImageList_Add, METH_VARARGS | METH_KEYWORDS, NULL},
21930 { (char *)"ImageList_AddWithColourMask", (PyCFunction) _wrap_ImageList_AddWithColourMask, METH_VARARGS | METH_KEYWORDS, NULL},
21931 { (char *)"ImageList_AddIcon", (PyCFunction) _wrap_ImageList_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21932 { (char *)"ImageList_GetBitmap", (PyCFunction) _wrap_ImageList_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21933 { (char *)"ImageList_GetIcon", (PyCFunction) _wrap_ImageList_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21934 { (char *)"ImageList_Replace", (PyCFunction) _wrap_ImageList_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
21935 { (char *)"ImageList_Draw", (PyCFunction) _wrap_ImageList_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
21936 { (char *)"ImageList_GetImageCount", (PyCFunction) _wrap_ImageList_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
21937 { (char *)"ImageList_Remove", (PyCFunction) _wrap_ImageList_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
21938 { (char *)"ImageList_RemoveAll", (PyCFunction) _wrap_ImageList_RemoveAll, METH_VARARGS | METH_KEYWORDS, NULL},
21939 { (char *)"ImageList_GetSize", (PyCFunction) _wrap_ImageList_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21940 { (char *)"ImageList_swigregister", ImageList_swigregister, METH_VARARGS, NULL},
21941 { (char *)"PenList_AddPen", (PyCFunction) _wrap_PenList_AddPen, METH_VARARGS | METH_KEYWORDS, NULL},
21942 { (char *)"PenList_FindOrCreatePen", (PyCFunction) _wrap_PenList_FindOrCreatePen, METH_VARARGS | METH_KEYWORDS, NULL},
21943 { (char *)"PenList_RemovePen", (PyCFunction) _wrap_PenList_RemovePen, METH_VARARGS | METH_KEYWORDS, NULL},
21944 { (char *)"PenList_GetCount", (PyCFunction) _wrap_PenList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21945 { (char *)"PenList_swigregister", PenList_swigregister, METH_VARARGS, NULL},
21946 { (char *)"BrushList_AddBrush", (PyCFunction) _wrap_BrushList_AddBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21947 { (char *)"BrushList_FindOrCreateBrush", (PyCFunction) _wrap_BrushList_FindOrCreateBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21948 { (char *)"BrushList_RemoveBrush", (PyCFunction) _wrap_BrushList_RemoveBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21949 { (char *)"BrushList_GetCount", (PyCFunction) _wrap_BrushList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21950 { (char *)"BrushList_swigregister", BrushList_swigregister, METH_VARARGS, NULL},
21951 { (char *)"new_ColourDatabase", (PyCFunction) _wrap_new_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
21952 { (char *)"delete_ColourDatabase", (PyCFunction) _wrap_delete_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
21953 { (char *)"ColourDatabase_Find", (PyCFunction) _wrap_ColourDatabase_Find, METH_VARARGS | METH_KEYWORDS, NULL},
21954 { (char *)"ColourDatabase_FindName", (PyCFunction) _wrap_ColourDatabase_FindName, METH_VARARGS | METH_KEYWORDS, NULL},
21955 { (char *)"ColourDatabase_AddColour", (PyCFunction) _wrap_ColourDatabase_AddColour, METH_VARARGS | METH_KEYWORDS, NULL},
21956 { (char *)"ColourDatabase_Append", (PyCFunction) _wrap_ColourDatabase_Append, METH_VARARGS | METH_KEYWORDS, NULL},
21957 { (char *)"ColourDatabase_swigregister", ColourDatabase_swigregister, METH_VARARGS, NULL},
21958 { (char *)"FontList_AddFont", (PyCFunction) _wrap_FontList_AddFont, METH_VARARGS | METH_KEYWORDS, NULL},
21959 { (char *)"FontList_FindOrCreateFont", (PyCFunction) _wrap_FontList_FindOrCreateFont, METH_VARARGS | METH_KEYWORDS, NULL},
21960 { (char *)"FontList_RemoveFont", (PyCFunction) _wrap_FontList_RemoveFont, METH_VARARGS | METH_KEYWORDS, NULL},
21961 { (char *)"FontList_GetCount", (PyCFunction) _wrap_FontList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21962 { (char *)"FontList_swigregister", FontList_swigregister, METH_VARARGS, NULL},
21963 { (char *)"new_Effects", (PyCFunction) _wrap_new_Effects, METH_VARARGS | METH_KEYWORDS, NULL},
21964 { (char *)"Effects_GetHighlightColour", (PyCFunction) _wrap_Effects_GetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
21965 { (char *)"Effects_GetLightShadow", (PyCFunction) _wrap_Effects_GetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21966 { (char *)"Effects_GetFaceColour", (PyCFunction) _wrap_Effects_GetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
21967 { (char *)"Effects_GetMediumShadow", (PyCFunction) _wrap_Effects_GetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21968 { (char *)"Effects_GetDarkShadow", (PyCFunction) _wrap_Effects_GetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21969 { (char *)"Effects_SetHighlightColour", (PyCFunction) _wrap_Effects_SetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
21970 { (char *)"Effects_SetLightShadow", (PyCFunction) _wrap_Effects_SetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21971 { (char *)"Effects_SetFaceColour", (PyCFunction) _wrap_Effects_SetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
21972 { (char *)"Effects_SetMediumShadow", (PyCFunction) _wrap_Effects_SetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21973 { (char *)"Effects_SetDarkShadow", (PyCFunction) _wrap_Effects_SetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21974 { (char *)"Effects_Set", (PyCFunction) _wrap_Effects_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21975 { (char *)"Effects_DrawSunkenEdge", (PyCFunction) _wrap_Effects_DrawSunkenEdge, METH_VARARGS | METH_KEYWORDS, NULL},
21976 { (char *)"Effects_TileBitmap", (PyCFunction) _wrap_Effects_TileBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21977 { (char *)"Effects_swigregister", Effects_swigregister, METH_VARARGS, NULL},
21978 { NULL, NULL, 0, NULL }
21979 };
21980
21981
21982 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
21983
21984 static void *_p_wxBufferedDCTo_p_wxMemoryDC(void *x) {
21985 return (void *)((wxMemoryDC *) ((wxBufferedDC *) x));
21986 }
21987 static void *_p_wxBufferedPaintDCTo_p_wxMemoryDC(void *x) {
21988 return (void *)((wxMemoryDC *) (wxBufferedDC *) ((wxBufferedPaintDC *) x));
21989 }
21990 static void *_p_wxIconTo_p_wxGDIObject(void *x) {
21991 return (void *)((wxGDIObject *) ((wxIcon *) x));
21992 }
21993 static void *_p_wxPaletteTo_p_wxGDIObject(void *x) {
21994 return (void *)((wxGDIObject *) ((wxPalette *) x));
21995 }
21996 static void *_p_wxPenTo_p_wxGDIObject(void *x) {
21997 return (void *)((wxGDIObject *) ((wxPen *) x));
21998 }
21999 static void *_p_wxFontTo_p_wxGDIObject(void *x) {
22000 return (void *)((wxGDIObject *) ((wxFont *) x));
22001 }
22002 static void *_p_wxCursorTo_p_wxGDIObject(void *x) {
22003 return (void *)((wxGDIObject *) ((wxCursor *) x));
22004 }
22005 static void *_p_wxBitmapTo_p_wxGDIObject(void *x) {
22006 return (void *)((wxGDIObject *) ((wxBitmap *) x));
22007 }
22008 static void *_p_wxRegionTo_p_wxGDIObject(void *x) {
22009 return (void *)((wxGDIObject *) ((wxRegion *) x));
22010 }
22011 static void *_p_wxBrushTo_p_wxGDIObject(void *x) {
22012 return (void *)((wxGDIObject *) ((wxBrush *) x));
22013 }
22014 static void *_p_wxBufferedDCTo_p_wxDC(void *x) {
22015 return (void *)((wxDC *) (wxMemoryDC *) ((wxBufferedDC *) x));
22016 }
22017 static void *_p_wxScreenDCTo_p_wxDC(void *x) {
22018 return (void *)((wxDC *) ((wxScreenDC *) x));
22019 }
22020 static void *_p_wxMirrorDCTo_p_wxDC(void *x) {
22021 return (void *)((wxDC *) ((wxMirrorDC *) x));
22022 }
22023 static void *_p_wxMemoryDCTo_p_wxDC(void *x) {
22024 return (void *)((wxDC *) ((wxMemoryDC *) x));
22025 }
22026 static void *_p_wxWindowDCTo_p_wxDC(void *x) {
22027 return (void *)((wxDC *) ((wxWindowDC *) x));
22028 }
22029 static void *_p_wxMetaFileDCTo_p_wxDC(void *x) {
22030 return (void *)((wxDC *) ((wxMetaFileDC *) x));
22031 }
22032 static void *_p_wxBufferedPaintDCTo_p_wxDC(void *x) {
22033 return (void *)((wxDC *) (wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
22034 }
22035 static void *_p_wxClientDCTo_p_wxDC(void *x) {
22036 return (void *)((wxDC *) ((wxClientDC *) x));
22037 }
22038 static void *_p_wxPaintDCTo_p_wxDC(void *x) {
22039 return (void *)((wxDC *) ((wxPaintDC *) x));
22040 }
22041 static void *_p_wxPostScriptDCTo_p_wxDC(void *x) {
22042 return (void *)((wxDC *) ((wxPostScriptDC *) x));
22043 }
22044 static void *_p_wxPrinterDCTo_p_wxDC(void *x) {
22045 return (void *)((wxDC *) ((wxPrinterDC *) x));
22046 }
22047 static void *_p_wxBufferedPaintDCTo_p_wxBufferedDC(void *x) {
22048 return (void *)((wxBufferedDC *) ((wxBufferedPaintDC *) x));
22049 }
22050 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
22051 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
22052 }
22053 static void *_p_wxPenTo_p_wxObject(void *x) {
22054 return (void *)((wxObject *) (wxGDIObject *) ((wxPen *) x));
22055 }
22056 static void *_p_wxRegionIteratorTo_p_wxObject(void *x) {
22057 return (void *)((wxObject *) ((wxRegionIterator *) x));
22058 }
22059 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
22060 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
22061 }
22062 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
22063 return (void *)((wxObject *) ((wxSizerItem *) x));
22064 }
22065 static void *_p_wxColourDatabaseTo_p_wxObject(void *x) {
22066 return (void *)((wxObject *) ((wxColourDatabase *) x));
22067 }
22068 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
22069 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
22070 }
22071 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
22072 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
22073 }
22074 static void *_p_wxIconTo_p_wxObject(void *x) {
22075 return (void *)((wxObject *) (wxGDIObject *) ((wxIcon *) x));
22076 }
22077 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
22078 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
22079 }
22080 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
22081 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
22082 }
22083 static void *_p_wxSizerTo_p_wxObject(void *x) {
22084 return (void *)((wxObject *) ((wxSizer *) x));
22085 }
22086 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
22087 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
22088 }
22089 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
22090 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
22091 }
22092 static void *_p_wxPenListTo_p_wxObject(void *x) {
22093 return (void *)((wxObject *) ((wxPenList *) x));
22094 }
22095 static void *_p_wxEventTo_p_wxObject(void *x) {
22096 return (void *)((wxObject *) ((wxEvent *) x));
22097 }
22098 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
22099 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
22100 }
22101 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
22102 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
22103 }
22104 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
22105 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
22106 }
22107 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
22108 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
22109 }
22110 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
22111 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
22112 }
22113 static void *_p_wxDCTo_p_wxObject(void *x) {
22114 return (void *)((wxObject *) ((wxDC *) x));
22115 }
22116 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
22117 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
22118 }
22119 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
22120 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
22121 }
22122 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
22123 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
22124 }
22125 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
22126 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
22127 }
22128 static void *_p_wxControlTo_p_wxObject(void *x) {
22129 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
22130 }
22131 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
22132 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
22133 }
22134 static void *_p_wxClientDCTo_p_wxObject(void *x) {
22135 return (void *)((wxObject *) (wxDC *) ((wxClientDC *) x));
22136 }
22137 static void *_p_wxFSFileTo_p_wxObject(void *x) {
22138 return (void *)((wxObject *) ((wxFSFile *) x));
22139 }
22140 static void *_p_wxMemoryDCTo_p_wxObject(void *x) {
22141 return (void *)((wxObject *) (wxDC *) ((wxMemoryDC *) x));
22142 }
22143 static void *_p_wxRegionTo_p_wxObject(void *x) {
22144 return (void *)((wxObject *) (wxGDIObject *) ((wxRegion *) x));
22145 }
22146 static void *_p_wxPySizerTo_p_wxObject(void *x) {
22147 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
22148 }
22149 static void *_p_wxWindowDCTo_p_wxObject(void *x) {
22150 return (void *)((wxObject *) (wxDC *) ((wxWindowDC *) x));
22151 }
22152 static void *_p_wxGDIObjectTo_p_wxObject(void *x) {
22153 return (void *)((wxObject *) ((wxGDIObject *) x));
22154 }
22155 static void *_p_wxEffectsTo_p_wxObject(void *x) {
22156 return (void *)((wxObject *) ((wxEffects *) x));
22157 }
22158 static void *_p_wxPyEventTo_p_wxObject(void *x) {
22159 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
22160 }
22161 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
22162 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
22163 }
22164 static void *_p_wxPostScriptDCTo_p_wxObject(void *x) {
22165 return (void *)((wxObject *) (wxDC *) ((wxPostScriptDC *) x));
22166 }
22167 static void *_p_wxShowEventTo_p_wxObject(void *x) {
22168 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
22169 }
22170 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
22171 return (void *)((wxObject *) ((wxMenuItem *) x));
22172 }
22173 static void *_p_wxDateEventTo_p_wxObject(void *x) {
22174 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
22175 }
22176 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
22177 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
22178 }
22179 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
22180 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
22181 }
22182 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
22183 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
22184 }
22185 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
22186 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
22187 }
22188 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
22189 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
22190 }
22191 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
22192 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
22193 }
22194 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
22195 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
22196 }
22197 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
22198 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
22199 }
22200 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
22201 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
22202 }
22203 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
22204 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
22205 }
22206 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
22207 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
22208 }
22209 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
22210 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
22211 }
22212 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
22213 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
22214 }
22215 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
22216 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
22217 }
22218 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
22219 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
22220 }
22221 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
22222 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
22223 }
22224 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
22225 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
22226 }
22227 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
22228 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
22229 }
22230 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
22231 return (void *)((wxObject *) ((wxImageHandler *) x));
22232 }
22233 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
22234 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
22235 }
22236 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
22237 return (void *)((wxObject *) ((wxEvtHandler *) x));
22238 }
22239 static void *_p_wxBufferedPaintDCTo_p_wxObject(void *x) {
22240 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
22241 }
22242 static void *_p_wxPaintDCTo_p_wxObject(void *x) {
22243 return (void *)((wxObject *) (wxDC *) ((wxPaintDC *) x));
22244 }
22245 static void *_p_wxPrinterDCTo_p_wxObject(void *x) {
22246 return (void *)((wxObject *) (wxDC *) ((wxPrinterDC *) x));
22247 }
22248 static void *_p_wxScreenDCTo_p_wxObject(void *x) {
22249 return (void *)((wxObject *) (wxDC *) ((wxScreenDC *) x));
22250 }
22251 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
22252 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
22253 }
22254 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
22255 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
22256 }
22257 static void *_p_wxImageTo_p_wxObject(void *x) {
22258 return (void *)((wxObject *) ((wxImage *) x));
22259 }
22260 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
22261 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
22262 }
22263 static void *_p_wxPaletteTo_p_wxObject(void *x) {
22264 return (void *)((wxObject *) (wxGDIObject *) ((wxPalette *) x));
22265 }
22266 static void *_p_wxBufferedDCTo_p_wxObject(void *x) {
22267 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *) ((wxBufferedDC *) x));
22268 }
22269 static void *_p_wxImageListTo_p_wxObject(void *x) {
22270 return (void *)((wxObject *) ((wxImageList *) x));
22271 }
22272 static void *_p_wxCursorTo_p_wxObject(void *x) {
22273 return (void *)((wxObject *) (wxGDIObject *) ((wxCursor *) x));
22274 }
22275 static void *_p_wxEncodingConverterTo_p_wxObject(void *x) {
22276 return (void *)((wxObject *) ((wxEncodingConverter *) x));
22277 }
22278 static void *_p_wxMirrorDCTo_p_wxObject(void *x) {
22279 return (void *)((wxObject *) (wxDC *) ((wxMirrorDC *) x));
22280 }
22281 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
22282 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
22283 }
22284 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
22285 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
22286 }
22287 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
22288 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
22289 }
22290 static void *_p_wxWindowTo_p_wxObject(void *x) {
22291 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
22292 }
22293 static void *_p_wxMenuTo_p_wxObject(void *x) {
22294 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
22295 }
22296 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
22297 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
22298 }
22299 static void *_p_wxMetaFileDCTo_p_wxObject(void *x) {
22300 return (void *)((wxObject *) (wxDC *) ((wxMetaFileDC *) x));
22301 }
22302 static void *_p_wxBrushListTo_p_wxObject(void *x) {
22303 return (void *)((wxObject *) ((wxBrushList *) x));
22304 }
22305 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
22306 return (void *)((wxObject *) ((wxFileSystem *) x));
22307 }
22308 static void *_p_wxBitmapTo_p_wxObject(void *x) {
22309 return (void *)((wxObject *) (wxGDIObject *) ((wxBitmap *) x));
22310 }
22311 static void *_p_wxMaskTo_p_wxObject(void *x) {
22312 return (void *)((wxObject *) ((wxMask *) x));
22313 }
22314 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
22315 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
22316 }
22317 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
22318 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
22319 }
22320 static void *_p_wxPyAppTo_p_wxObject(void *x) {
22321 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
22322 }
22323 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
22324 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
22325 }
22326 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
22327 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
22328 }
22329 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
22330 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
22331 }
22332 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
22333 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
22334 }
22335 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
22336 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
22337 }
22338 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
22339 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
22340 }
22341 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
22342 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
22343 }
22344 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
22345 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
22346 }
22347 static void *_p_wxFontTo_p_wxObject(void *x) {
22348 return (void *)((wxObject *) (wxGDIObject *) ((wxFont *) x));
22349 }
22350 static void *_p_wxBrushTo_p_wxObject(void *x) {
22351 return (void *)((wxObject *) (wxGDIObject *) ((wxBrush *) x));
22352 }
22353 static void *_p_wxMetaFileTo_p_wxObject(void *x) {
22354 return (void *)((wxObject *) ((wxMetaFile *) x));
22355 }
22356 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
22357 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
22358 }
22359 static void *_p_wxColourTo_p_wxObject(void *x) {
22360 return (void *)((wxObject *) ((wxColour *) x));
22361 }
22362 static void *_p_wxFontListTo_p_wxObject(void *x) {
22363 return (void *)((wxObject *) ((wxFontList *) x));
22364 }
22365 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
22366 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
22367 }
22368 static void *_p_wxValidatorTo_p_wxObject(void *x) {
22369 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
22370 }
22371 static void *_p_wxControlTo_p_wxWindow(void *x) {
22372 return (void *)((wxWindow *) ((wxControl *) x));
22373 }
22374 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
22375 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
22376 }
22377 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
22378 return (void *)((wxWindow *) ((wxMenuBar *) x));
22379 }
22380 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}};
22381 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}};
22382 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}};
22383 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}};
22384 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}};
22385 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}};
22386 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}};
22387 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}};
22388 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}};
22389 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}};
22390 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}};
22391 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}};
22392 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}};
22393 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}};
22394 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}};
22395 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}};
22396 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}};
22397 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}};
22398 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}};
22399 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}};
22400 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}};
22401 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}};
22402 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}};
22403 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxRegionIterator", _p_wxRegionIteratorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPen", _p_wxPenTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxColourDatabase", _p_wxColourDatabaseTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPenList", _p_wxPenListTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMask", _p_wxMaskTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFont", _p_wxFontTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxClientDC", _p_wxClientDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMemoryDC", _p_wxMemoryDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxRegion", _p_wxRegionTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDC", _p_wxDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIcon", _p_wxIconTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDC", _p_wxWindowDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGDIObject", _p_wxGDIObjectTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEffects", _p_wxEffectsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPostScriptDC", _p_wxPostScriptDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintDC", _p_wxPaintDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBufferedPaintDC", _p_wxBufferedPaintDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPrinterDC", _p_wxPrinterDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScreenDC", _p_wxScreenDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBufferedDC", _p_wxBufferedDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPalette", _p_wxPaletteTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageList", _p_wxImageListTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCursor", _p_wxCursorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxMirrorDC", _p_wxMirrorDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEncodingConverter", _p_wxEncodingConverterTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMetaFileDC", _p_wxMetaFileDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBrushList", _p_wxBrushListTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBitmap", _p_wxBitmapTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBrush", _p_wxBrushTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMetaFile", _p_wxMetaFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxColour", _p_wxColourTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFontList", _p_wxFontListTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
22404 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}};
22405 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}};
22406 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}};
22407 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}};
22408 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}};
22409 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}};
22410 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}};
22411 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}};
22412 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}};
22413 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}};
22414 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}};
22415 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}};
22416 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}};
22417 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}};
22418 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}};
22419 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}};
22420 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}};
22421 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}};
22422 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}};
22423 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}};
22424 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}};
22425 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}};
22426 static swig_type_info _swigt__p_wxConfigBase[] = {{"_p_wxConfigBase", 0, "wxConfigBase *", 0, 0, 0, 0},{"_p_wxConfigBase", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
22427 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}};
22428 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}};
22429 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}};
22430 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}};
22431 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}};
22432 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}};
22433 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}};
22434 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}};
22435 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}};
22436 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}};
22437 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}};
22438 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}};
22439 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}};
22440 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}};
22441 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}};
22442
22443 static swig_type_info *swig_types_initial[] = {
22444 _swigt__p_wxPostScriptDC,
22445 _swigt__p_wxBrush,
22446 _swigt__p_wxColour,
22447 _swigt__p_wxDC,
22448 _swigt__p_wxMirrorDC,
22449 _swigt__p_form_ops_t,
22450 _swigt__p_wxDuplexMode,
22451 _swigt__p_wxPyFontEnumerator,
22452 _swigt__p_char,
22453 _swigt__p_wxIconLocation,
22454 _swigt__p_wxImage,
22455 _swigt__p_wxMetaFileDC,
22456 _swigt__p_wxMask,
22457 _swigt__p_wxSize,
22458 _swigt__p_wxFont,
22459 _swigt__p_wxWindow,
22460 _swigt__p_double,
22461 _swigt__p_wxMemoryDC,
22462 _swigt__p_wxFontMapper,
22463 _swigt__p_wxEffects,
22464 _swigt__p_wxNativeEncodingInfo,
22465 _swigt__p_wxPalette,
22466 _swigt__p_wxBitmap,
22467 _swigt__p_wxObject,
22468 _swigt__p_wxRegionIterator,
22469 _swigt__p_wxRect,
22470 _swigt__p_wxPaperSize,
22471 _swigt__p_wxString,
22472 _swigt__unsigned_int,
22473 _swigt__p_unsigned_int,
22474 _swigt__p_wxPrinterDC,
22475 _swigt__p_wxIconBundle,
22476 _swigt__p_wxPoint,
22477 _swigt__p_wxDash,
22478 _swigt__p_wxScreenDC,
22479 _swigt__p_wxCursor,
22480 _swigt__p_wxClientDC,
22481 _swigt__p_wxBufferedDC,
22482 _swigt__p_wxImageList,
22483 _swigt__p_unsigned_char,
22484 _swigt__p_wxGDIObject,
22485 _swigt__p_wxIcon,
22486 _swigt__p_wxLocale,
22487 _swigt__ptrdiff_t,
22488 _swigt__std__ptrdiff_t,
22489 _swigt__p_wxRegion,
22490 _swigt__p_wxConfigBase,
22491 _swigt__p_wxLanguageInfo,
22492 _swigt__p_wxWindowDC,
22493 _swigt__p_wxPrintData,
22494 _swigt__p_wxBrushList,
22495 _swigt__p_wxFontList,
22496 _swigt__p_wxPen,
22497 _swigt__p_wxBufferedPaintDC,
22498 _swigt__p_wxPaintDC,
22499 _swigt__p_wxPenList,
22500 _swigt__p_int,
22501 _swigt__p_wxMetaFile,
22502 _swigt__p_unsigned_long,
22503 _swigt__p_wxNativeFontInfo,
22504 _swigt__p_wxEncodingConverter,
22505 _swigt__p_wxColourDatabase,
22506 0
22507 };
22508
22509
22510 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
22511
22512 static swig_const_info swig_const_table[] = {
22513 {0, 0, 0, 0.0, 0, 0}};
22514
22515 #ifdef __cplusplus
22516 }
22517 #endif
22518
22519
22520 #ifdef __cplusplus
22521 extern "C" {
22522 #endif
22523
22524 /* Python-specific SWIG API */
22525 #define SWIG_newvarlink() SWIG_Python_newvarlink()
22526 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
22527 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
22528
22529 /* -----------------------------------------------------------------------------
22530 * global variable support code.
22531 * ----------------------------------------------------------------------------- */
22532
22533 typedef struct swig_globalvar {
22534 char *name; /* Name of global variable */
22535 PyObject *(*get_attr)(); /* Return the current value */
22536 int (*set_attr)(PyObject *); /* Set the value */
22537 struct swig_globalvar *next;
22538 } swig_globalvar;
22539
22540 typedef struct swig_varlinkobject {
22541 PyObject_HEAD
22542 swig_globalvar *vars;
22543 } swig_varlinkobject;
22544
22545 static PyObject *
22546 swig_varlink_repr(swig_varlinkobject *v) {
22547 v = v;
22548 return PyString_FromString("<Swig global variables>");
22549 }
22550
22551 static int
22552 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
22553 swig_globalvar *var;
22554 flags = flags;
22555 fprintf(fp,"Swig global variables { ");
22556 for (var = v->vars; var; var=var->next) {
22557 fprintf(fp,"%s", var->name);
22558 if (var->next) fprintf(fp,", ");
22559 }
22560 fprintf(fp," }\n");
22561 return 0;
22562 }
22563
22564 static PyObject *
22565 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
22566 swig_globalvar *var = v->vars;
22567 while (var) {
22568 if (strcmp(var->name,n) == 0) {
22569 return (*var->get_attr)();
22570 }
22571 var = var->next;
22572 }
22573 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22574 return NULL;
22575 }
22576
22577 static int
22578 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
22579 swig_globalvar *var = v->vars;
22580 while (var) {
22581 if (strcmp(var->name,n) == 0) {
22582 return (*var->set_attr)(p);
22583 }
22584 var = var->next;
22585 }
22586 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22587 return 1;
22588 }
22589
22590 static PyTypeObject varlinktype = {
22591 PyObject_HEAD_INIT(0)
22592 0, /* Number of items in variable part (ob_size) */
22593 (char *)"swigvarlink", /* Type name (tp_name) */
22594 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
22595 0, /* Itemsize (tp_itemsize) */
22596 0, /* Deallocator (tp_dealloc) */
22597 (printfunc) swig_varlink_print, /* Print (tp_print) */
22598 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
22599 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
22600 0, /* tp_compare */
22601 (reprfunc) swig_varlink_repr, /* tp_repr */
22602 0, /* tp_as_number */
22603 0, /* tp_as_sequence */
22604 0, /* tp_as_mapping */
22605 0, /* tp_hash */
22606 0, /* tp_call */
22607 0, /* tp_str */
22608 0, /* tp_getattro */
22609 0, /* tp_setattro */
22610 0, /* tp_as_buffer */
22611 0, /* tp_flags */
22612 0, /* tp_doc */
22613 #if PY_VERSION_HEX >= 0x02000000
22614 0, /* tp_traverse */
22615 0, /* tp_clear */
22616 #endif
22617 #if PY_VERSION_HEX >= 0x02010000
22618 0, /* tp_richcompare */
22619 0, /* tp_weaklistoffset */
22620 #endif
22621 #if PY_VERSION_HEX >= 0x02020000
22622 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
22623 #endif
22624 #if PY_VERSION_HEX >= 0x02030000
22625 0, /* tp_del */
22626 #endif
22627 #ifdef COUNT_ALLOCS
22628 0,0,0,0 /* tp_alloc -> tp_next */
22629 #endif
22630 };
22631
22632 /* Create a variable linking object for use later */
22633 static PyObject *
22634 SWIG_Python_newvarlink(void) {
22635 swig_varlinkobject *result = 0;
22636 result = PyMem_NEW(swig_varlinkobject,1);
22637 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
22638 result->ob_type = &varlinktype;
22639 result->vars = 0;
22640 result->ob_refcnt = 0;
22641 Py_XINCREF((PyObject *) result);
22642 return ((PyObject*) result);
22643 }
22644
22645 static void
22646 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
22647 swig_varlinkobject *v;
22648 swig_globalvar *gv;
22649 v= (swig_varlinkobject *) p;
22650 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
22651 gv->name = (char *) malloc(strlen(name)+1);
22652 strcpy(gv->name,name);
22653 gv->get_attr = get_attr;
22654 gv->set_attr = set_attr;
22655 gv->next = v->vars;
22656 v->vars = gv;
22657 }
22658
22659 /* -----------------------------------------------------------------------------
22660 * constants/methods manipulation
22661 * ----------------------------------------------------------------------------- */
22662
22663 /* Install Constants */
22664 static void
22665 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
22666 PyObject *obj = 0;
22667 size_t i;
22668 for (i = 0; constants[i].type; i++) {
22669 switch(constants[i].type) {
22670 case SWIG_PY_INT:
22671 obj = PyInt_FromLong(constants[i].lvalue);
22672 break;
22673 case SWIG_PY_FLOAT:
22674 obj = PyFloat_FromDouble(constants[i].dvalue);
22675 break;
22676 case SWIG_PY_STRING:
22677 if (constants[i].pvalue) {
22678 obj = PyString_FromString((char *) constants[i].pvalue);
22679 } else {
22680 Py_INCREF(Py_None);
22681 obj = Py_None;
22682 }
22683 break;
22684 case SWIG_PY_POINTER:
22685 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
22686 break;
22687 case SWIG_PY_BINARY:
22688 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
22689 break;
22690 default:
22691 obj = 0;
22692 break;
22693 }
22694 if (obj) {
22695 PyDict_SetItemString(d,constants[i].name,obj);
22696 Py_DECREF(obj);
22697 }
22698 }
22699 }
22700
22701 /* -----------------------------------------------------------------------------*/
22702 /* Fix SwigMethods to carry the callback ptrs when needed */
22703 /* -----------------------------------------------------------------------------*/
22704
22705 static void
22706 SWIG_Python_FixMethods(PyMethodDef *methods,
22707 swig_const_info *const_table,
22708 swig_type_info **types,
22709 swig_type_info **types_initial) {
22710 size_t i;
22711 for (i = 0; methods[i].ml_name; ++i) {
22712 char *c = methods[i].ml_doc;
22713 if (c && (c = strstr(c, "swig_ptr: "))) {
22714 int j;
22715 swig_const_info *ci = 0;
22716 char *name = c + 10;
22717 for (j = 0; const_table[j].type; j++) {
22718 if (strncmp(const_table[j].name, name,
22719 strlen(const_table[j].name)) == 0) {
22720 ci = &(const_table[j]);
22721 break;
22722 }
22723 }
22724 if (ci) {
22725 size_t shift = (ci->ptype) - types;
22726 swig_type_info *ty = types_initial[shift];
22727 size_t ldoc = (c - methods[i].ml_doc);
22728 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
22729 char *ndoc = (char*)malloc(ldoc + lptr + 10);
22730 char *buff = ndoc;
22731 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
22732 strncpy(buff, methods[i].ml_doc, ldoc);
22733 buff += ldoc;
22734 strncpy(buff, "swig_ptr: ", 10);
22735 buff += 10;
22736 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
22737 methods[i].ml_doc = ndoc;
22738 }
22739 }
22740 }
22741 }
22742
22743 /* -----------------------------------------------------------------------------*
22744 * Initialize type list
22745 * -----------------------------------------------------------------------------*/
22746
22747 #if PY_MAJOR_VERSION < 2
22748 /* PyModule_AddObject function was introduced in Python 2.0. The following function
22749 is copied out of Python/modsupport.c in python version 2.3.4 */
22750 static int
22751 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
22752 {
22753 PyObject *dict;
22754 if (!PyModule_Check(m)) {
22755 PyErr_SetString(PyExc_TypeError,
22756 "PyModule_AddObject() needs module as first arg");
22757 return -1;
22758 }
22759 if (!o) {
22760 PyErr_SetString(PyExc_TypeError,
22761 "PyModule_AddObject() needs non-NULL value");
22762 return -1;
22763 }
22764
22765 dict = PyModule_GetDict(m);
22766 if (dict == NULL) {
22767 /* Internal error -- modules must have a dict! */
22768 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
22769 PyModule_GetName(m));
22770 return -1;
22771 }
22772 if (PyDict_SetItemString(dict, name, o))
22773 return -1;
22774 Py_DECREF(o);
22775 return 0;
22776 }
22777 #endif
22778
22779 static swig_type_info **
22780 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
22781 static PyMethodDef swig_empty_runtime_method_table[] = {
22782 {
22783 NULL, NULL, 0, NULL
22784 }
22785 };/* Sentinel */
22786
22787 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
22788 swig_empty_runtime_method_table);
22789 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
22790 if (pointer && module) {
22791 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
22792 }
22793 return type_list_handle;
22794 }
22795
22796 static swig_type_info **
22797 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
22798 swig_type_info **type_pointer;
22799
22800 /* first check if module already created */
22801 type_pointer = SWIG_Python_GetTypeListHandle();
22802 if (type_pointer) {
22803 return type_pointer;
22804 } else {
22805 /* create a new module and variable */
22806 return SWIG_Python_SetTypeListHandle(type_list_handle);
22807 }
22808 }
22809
22810 #ifdef __cplusplus
22811 }
22812 #endif
22813
22814 /* -----------------------------------------------------------------------------*
22815 * Partial Init method
22816 * -----------------------------------------------------------------------------*/
22817
22818 #ifdef SWIG_LINK_RUNTIME
22819 #ifdef __cplusplus
22820 extern "C"
22821 #endif
22822 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
22823 #endif
22824
22825 #ifdef __cplusplus
22826 extern "C"
22827 #endif
22828 SWIGEXPORT(void) SWIG_init(void) {
22829 static PyObject *SWIG_globals = 0;
22830 static int typeinit = 0;
22831 PyObject *m, *d;
22832 int i;
22833 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
22834
22835 /* Fix SwigMethods to carry the callback ptrs when needed */
22836 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
22837
22838 m = Py_InitModule((char *) SWIG_name, SwigMethods);
22839 d = PyModule_GetDict(m);
22840
22841 if (!typeinit) {
22842 #ifdef SWIG_LINK_RUNTIME
22843 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
22844 #else
22845 # ifndef SWIG_STATIC_RUNTIME
22846 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
22847 # endif
22848 #endif
22849 for (i = 0; swig_types_initial[i]; i++) {
22850 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
22851 }
22852 typeinit = 1;
22853 }
22854 SWIG_InstallConstants(d,swig_const_table);
22855
22856 {
22857 PyDict_SetItemString(d,"OutRegion", SWIG_From_int((int)(wxOutRegion)));
22858 }
22859 {
22860 PyDict_SetItemString(d,"PartRegion", SWIG_From_int((int)(wxPartRegion)));
22861 }
22862 {
22863 PyDict_SetItemString(d,"InRegion", SWIG_From_int((int)(wxInRegion)));
22864 }
22865 {
22866 PyDict_SetItemString(d,"FONTFAMILY_DEFAULT", SWIG_From_int((int)(wxFONTFAMILY_DEFAULT)));
22867 }
22868 {
22869 PyDict_SetItemString(d,"FONTFAMILY_DECORATIVE", SWIG_From_int((int)(wxFONTFAMILY_DECORATIVE)));
22870 }
22871 {
22872 PyDict_SetItemString(d,"FONTFAMILY_ROMAN", SWIG_From_int((int)(wxFONTFAMILY_ROMAN)));
22873 }
22874 {
22875 PyDict_SetItemString(d,"FONTFAMILY_SCRIPT", SWIG_From_int((int)(wxFONTFAMILY_SCRIPT)));
22876 }
22877 {
22878 PyDict_SetItemString(d,"FONTFAMILY_SWISS", SWIG_From_int((int)(wxFONTFAMILY_SWISS)));
22879 }
22880 {
22881 PyDict_SetItemString(d,"FONTFAMILY_MODERN", SWIG_From_int((int)(wxFONTFAMILY_MODERN)));
22882 }
22883 {
22884 PyDict_SetItemString(d,"FONTFAMILY_TELETYPE", SWIG_From_int((int)(wxFONTFAMILY_TELETYPE)));
22885 }
22886 {
22887 PyDict_SetItemString(d,"FONTFAMILY_MAX", SWIG_From_int((int)(wxFONTFAMILY_MAX)));
22888 }
22889 {
22890 PyDict_SetItemString(d,"FONTFAMILY_UNKNOWN", SWIG_From_int((int)(wxFONTFAMILY_UNKNOWN)));
22891 }
22892 {
22893 PyDict_SetItemString(d,"FONTSTYLE_NORMAL", SWIG_From_int((int)(wxFONTSTYLE_NORMAL)));
22894 }
22895 {
22896 PyDict_SetItemString(d,"FONTSTYLE_ITALIC", SWIG_From_int((int)(wxFONTSTYLE_ITALIC)));
22897 }
22898 {
22899 PyDict_SetItemString(d,"FONTSTYLE_SLANT", SWIG_From_int((int)(wxFONTSTYLE_SLANT)));
22900 }
22901 {
22902 PyDict_SetItemString(d,"FONTSTYLE_MAX", SWIG_From_int((int)(wxFONTSTYLE_MAX)));
22903 }
22904 {
22905 PyDict_SetItemString(d,"FONTWEIGHT_NORMAL", SWIG_From_int((int)(wxFONTWEIGHT_NORMAL)));
22906 }
22907 {
22908 PyDict_SetItemString(d,"FONTWEIGHT_LIGHT", SWIG_From_int((int)(wxFONTWEIGHT_LIGHT)));
22909 }
22910 {
22911 PyDict_SetItemString(d,"FONTWEIGHT_BOLD", SWIG_From_int((int)(wxFONTWEIGHT_BOLD)));
22912 }
22913 {
22914 PyDict_SetItemString(d,"FONTWEIGHT_MAX", SWIG_From_int((int)(wxFONTWEIGHT_MAX)));
22915 }
22916 {
22917 PyDict_SetItemString(d,"FONTFLAG_DEFAULT", SWIG_From_int((int)(wxFONTFLAG_DEFAULT)));
22918 }
22919 {
22920 PyDict_SetItemString(d,"FONTFLAG_ITALIC", SWIG_From_int((int)(wxFONTFLAG_ITALIC)));
22921 }
22922 {
22923 PyDict_SetItemString(d,"FONTFLAG_SLANT", SWIG_From_int((int)(wxFONTFLAG_SLANT)));
22924 }
22925 {
22926 PyDict_SetItemString(d,"FONTFLAG_LIGHT", SWIG_From_int((int)(wxFONTFLAG_LIGHT)));
22927 }
22928 {
22929 PyDict_SetItemString(d,"FONTFLAG_BOLD", SWIG_From_int((int)(wxFONTFLAG_BOLD)));
22930 }
22931 {
22932 PyDict_SetItemString(d,"FONTFLAG_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_ANTIALIASED)));
22933 }
22934 {
22935 PyDict_SetItemString(d,"FONTFLAG_NOT_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_NOT_ANTIALIASED)));
22936 }
22937 {
22938 PyDict_SetItemString(d,"FONTFLAG_UNDERLINED", SWIG_From_int((int)(wxFONTFLAG_UNDERLINED)));
22939 }
22940 {
22941 PyDict_SetItemString(d,"FONTFLAG_STRIKETHROUGH", SWIG_From_int((int)(wxFONTFLAG_STRIKETHROUGH)));
22942 }
22943 {
22944 PyDict_SetItemString(d,"FONTFLAG_MASK", SWIG_From_int((int)(wxFONTFLAG_MASK)));
22945 }
22946 {
22947 PyDict_SetItemString(d,"FONTENCODING_SYSTEM", SWIG_From_int((int)(wxFONTENCODING_SYSTEM)));
22948 }
22949 {
22950 PyDict_SetItemString(d,"FONTENCODING_DEFAULT", SWIG_From_int((int)(wxFONTENCODING_DEFAULT)));
22951 }
22952 {
22953 PyDict_SetItemString(d,"FONTENCODING_ISO8859_1", SWIG_From_int((int)(wxFONTENCODING_ISO8859_1)));
22954 }
22955 {
22956 PyDict_SetItemString(d,"FONTENCODING_ISO8859_2", SWIG_From_int((int)(wxFONTENCODING_ISO8859_2)));
22957 }
22958 {
22959 PyDict_SetItemString(d,"FONTENCODING_ISO8859_3", SWIG_From_int((int)(wxFONTENCODING_ISO8859_3)));
22960 }
22961 {
22962 PyDict_SetItemString(d,"FONTENCODING_ISO8859_4", SWIG_From_int((int)(wxFONTENCODING_ISO8859_4)));
22963 }
22964 {
22965 PyDict_SetItemString(d,"FONTENCODING_ISO8859_5", SWIG_From_int((int)(wxFONTENCODING_ISO8859_5)));
22966 }
22967 {
22968 PyDict_SetItemString(d,"FONTENCODING_ISO8859_6", SWIG_From_int((int)(wxFONTENCODING_ISO8859_6)));
22969 }
22970 {
22971 PyDict_SetItemString(d,"FONTENCODING_ISO8859_7", SWIG_From_int((int)(wxFONTENCODING_ISO8859_7)));
22972 }
22973 {
22974 PyDict_SetItemString(d,"FONTENCODING_ISO8859_8", SWIG_From_int((int)(wxFONTENCODING_ISO8859_8)));
22975 }
22976 {
22977 PyDict_SetItemString(d,"FONTENCODING_ISO8859_9", SWIG_From_int((int)(wxFONTENCODING_ISO8859_9)));
22978 }
22979 {
22980 PyDict_SetItemString(d,"FONTENCODING_ISO8859_10", SWIG_From_int((int)(wxFONTENCODING_ISO8859_10)));
22981 }
22982 {
22983 PyDict_SetItemString(d,"FONTENCODING_ISO8859_11", SWIG_From_int((int)(wxFONTENCODING_ISO8859_11)));
22984 }
22985 {
22986 PyDict_SetItemString(d,"FONTENCODING_ISO8859_12", SWIG_From_int((int)(wxFONTENCODING_ISO8859_12)));
22987 }
22988 {
22989 PyDict_SetItemString(d,"FONTENCODING_ISO8859_13", SWIG_From_int((int)(wxFONTENCODING_ISO8859_13)));
22990 }
22991 {
22992 PyDict_SetItemString(d,"FONTENCODING_ISO8859_14", SWIG_From_int((int)(wxFONTENCODING_ISO8859_14)));
22993 }
22994 {
22995 PyDict_SetItemString(d,"FONTENCODING_ISO8859_15", SWIG_From_int((int)(wxFONTENCODING_ISO8859_15)));
22996 }
22997 {
22998 PyDict_SetItemString(d,"FONTENCODING_ISO8859_MAX", SWIG_From_int((int)(wxFONTENCODING_ISO8859_MAX)));
22999 }
23000 {
23001 PyDict_SetItemString(d,"FONTENCODING_KOI8", SWIG_From_int((int)(wxFONTENCODING_KOI8)));
23002 }
23003 {
23004 PyDict_SetItemString(d,"FONTENCODING_KOI8_U", SWIG_From_int((int)(wxFONTENCODING_KOI8_U)));
23005 }
23006 {
23007 PyDict_SetItemString(d,"FONTENCODING_ALTERNATIVE", SWIG_From_int((int)(wxFONTENCODING_ALTERNATIVE)));
23008 }
23009 {
23010 PyDict_SetItemString(d,"FONTENCODING_BULGARIAN", SWIG_From_int((int)(wxFONTENCODING_BULGARIAN)));
23011 }
23012 {
23013 PyDict_SetItemString(d,"FONTENCODING_CP437", SWIG_From_int((int)(wxFONTENCODING_CP437)));
23014 }
23015 {
23016 PyDict_SetItemString(d,"FONTENCODING_CP850", SWIG_From_int((int)(wxFONTENCODING_CP850)));
23017 }
23018 {
23019 PyDict_SetItemString(d,"FONTENCODING_CP852", SWIG_From_int((int)(wxFONTENCODING_CP852)));
23020 }
23021 {
23022 PyDict_SetItemString(d,"FONTENCODING_CP855", SWIG_From_int((int)(wxFONTENCODING_CP855)));
23023 }
23024 {
23025 PyDict_SetItemString(d,"FONTENCODING_CP866", SWIG_From_int((int)(wxFONTENCODING_CP866)));
23026 }
23027 {
23028 PyDict_SetItemString(d,"FONTENCODING_CP874", SWIG_From_int((int)(wxFONTENCODING_CP874)));
23029 }
23030 {
23031 PyDict_SetItemString(d,"FONTENCODING_CP932", SWIG_From_int((int)(wxFONTENCODING_CP932)));
23032 }
23033 {
23034 PyDict_SetItemString(d,"FONTENCODING_CP936", SWIG_From_int((int)(wxFONTENCODING_CP936)));
23035 }
23036 {
23037 PyDict_SetItemString(d,"FONTENCODING_CP949", SWIG_From_int((int)(wxFONTENCODING_CP949)));
23038 }
23039 {
23040 PyDict_SetItemString(d,"FONTENCODING_CP950", SWIG_From_int((int)(wxFONTENCODING_CP950)));
23041 }
23042 {
23043 PyDict_SetItemString(d,"FONTENCODING_CP1250", SWIG_From_int((int)(wxFONTENCODING_CP1250)));
23044 }
23045 {
23046 PyDict_SetItemString(d,"FONTENCODING_CP1251", SWIG_From_int((int)(wxFONTENCODING_CP1251)));
23047 }
23048 {
23049 PyDict_SetItemString(d,"FONTENCODING_CP1252", SWIG_From_int((int)(wxFONTENCODING_CP1252)));
23050 }
23051 {
23052 PyDict_SetItemString(d,"FONTENCODING_CP1253", SWIG_From_int((int)(wxFONTENCODING_CP1253)));
23053 }
23054 {
23055 PyDict_SetItemString(d,"FONTENCODING_CP1254", SWIG_From_int((int)(wxFONTENCODING_CP1254)));
23056 }
23057 {
23058 PyDict_SetItemString(d,"FONTENCODING_CP1255", SWIG_From_int((int)(wxFONTENCODING_CP1255)));
23059 }
23060 {
23061 PyDict_SetItemString(d,"FONTENCODING_CP1256", SWIG_From_int((int)(wxFONTENCODING_CP1256)));
23062 }
23063 {
23064 PyDict_SetItemString(d,"FONTENCODING_CP1257", SWIG_From_int((int)(wxFONTENCODING_CP1257)));
23065 }
23066 {
23067 PyDict_SetItemString(d,"FONTENCODING_CP12_MAX", SWIG_From_int((int)(wxFONTENCODING_CP12_MAX)));
23068 }
23069 {
23070 PyDict_SetItemString(d,"FONTENCODING_UTF7", SWIG_From_int((int)(wxFONTENCODING_UTF7)));
23071 }
23072 {
23073 PyDict_SetItemString(d,"FONTENCODING_UTF8", SWIG_From_int((int)(wxFONTENCODING_UTF8)));
23074 }
23075 {
23076 PyDict_SetItemString(d,"FONTENCODING_EUC_JP", SWIG_From_int((int)(wxFONTENCODING_EUC_JP)));
23077 }
23078 {
23079 PyDict_SetItemString(d,"FONTENCODING_UTF16BE", SWIG_From_int((int)(wxFONTENCODING_UTF16BE)));
23080 }
23081 {
23082 PyDict_SetItemString(d,"FONTENCODING_UTF16LE", SWIG_From_int((int)(wxFONTENCODING_UTF16LE)));
23083 }
23084 {
23085 PyDict_SetItemString(d,"FONTENCODING_UTF32BE", SWIG_From_int((int)(wxFONTENCODING_UTF32BE)));
23086 }
23087 {
23088 PyDict_SetItemString(d,"FONTENCODING_UTF32LE", SWIG_From_int((int)(wxFONTENCODING_UTF32LE)));
23089 }
23090 {
23091 PyDict_SetItemString(d,"FONTENCODING_MACROMAN", SWIG_From_int((int)(wxFONTENCODING_MACROMAN)));
23092 }
23093 {
23094 PyDict_SetItemString(d,"FONTENCODING_MACJAPANESE", SWIG_From_int((int)(wxFONTENCODING_MACJAPANESE)));
23095 }
23096 {
23097 PyDict_SetItemString(d,"FONTENCODING_MACCHINESETRAD", SWIG_From_int((int)(wxFONTENCODING_MACCHINESETRAD)));
23098 }
23099 {
23100 PyDict_SetItemString(d,"FONTENCODING_MACKOREAN", SWIG_From_int((int)(wxFONTENCODING_MACKOREAN)));
23101 }
23102 {
23103 PyDict_SetItemString(d,"FONTENCODING_MACARABIC", SWIG_From_int((int)(wxFONTENCODING_MACARABIC)));
23104 }
23105 {
23106 PyDict_SetItemString(d,"FONTENCODING_MACHEBREW", SWIG_From_int((int)(wxFONTENCODING_MACHEBREW)));
23107 }
23108 {
23109 PyDict_SetItemString(d,"FONTENCODING_MACGREEK", SWIG_From_int((int)(wxFONTENCODING_MACGREEK)));
23110 }
23111 {
23112 PyDict_SetItemString(d,"FONTENCODING_MACCYRILLIC", SWIG_From_int((int)(wxFONTENCODING_MACCYRILLIC)));
23113 }
23114 {
23115 PyDict_SetItemString(d,"FONTENCODING_MACDEVANAGARI", SWIG_From_int((int)(wxFONTENCODING_MACDEVANAGARI)));
23116 }
23117 {
23118 PyDict_SetItemString(d,"FONTENCODING_MACGURMUKHI", SWIG_From_int((int)(wxFONTENCODING_MACGURMUKHI)));
23119 }
23120 {
23121 PyDict_SetItemString(d,"FONTENCODING_MACGUJARATI", SWIG_From_int((int)(wxFONTENCODING_MACGUJARATI)));
23122 }
23123 {
23124 PyDict_SetItemString(d,"FONTENCODING_MACORIYA", SWIG_From_int((int)(wxFONTENCODING_MACORIYA)));
23125 }
23126 {
23127 PyDict_SetItemString(d,"FONTENCODING_MACBENGALI", SWIG_From_int((int)(wxFONTENCODING_MACBENGALI)));
23128 }
23129 {
23130 PyDict_SetItemString(d,"FONTENCODING_MACTAMIL", SWIG_From_int((int)(wxFONTENCODING_MACTAMIL)));
23131 }
23132 {
23133 PyDict_SetItemString(d,"FONTENCODING_MACTELUGU", SWIG_From_int((int)(wxFONTENCODING_MACTELUGU)));
23134 }
23135 {
23136 PyDict_SetItemString(d,"FONTENCODING_MACKANNADA", SWIG_From_int((int)(wxFONTENCODING_MACKANNADA)));
23137 }
23138 {
23139 PyDict_SetItemString(d,"FONTENCODING_MACMALAJALAM", SWIG_From_int((int)(wxFONTENCODING_MACMALAJALAM)));
23140 }
23141 {
23142 PyDict_SetItemString(d,"FONTENCODING_MACSINHALESE", SWIG_From_int((int)(wxFONTENCODING_MACSINHALESE)));
23143 }
23144 {
23145 PyDict_SetItemString(d,"FONTENCODING_MACBURMESE", SWIG_From_int((int)(wxFONTENCODING_MACBURMESE)));
23146 }
23147 {
23148 PyDict_SetItemString(d,"FONTENCODING_MACKHMER", SWIG_From_int((int)(wxFONTENCODING_MACKHMER)));
23149 }
23150 {
23151 PyDict_SetItemString(d,"FONTENCODING_MACTHAI", SWIG_From_int((int)(wxFONTENCODING_MACTHAI)));
23152 }
23153 {
23154 PyDict_SetItemString(d,"FONTENCODING_MACLAOTIAN", SWIG_From_int((int)(wxFONTENCODING_MACLAOTIAN)));
23155 }
23156 {
23157 PyDict_SetItemString(d,"FONTENCODING_MACGEORGIAN", SWIG_From_int((int)(wxFONTENCODING_MACGEORGIAN)));
23158 }
23159 {
23160 PyDict_SetItemString(d,"FONTENCODING_MACARMENIAN", SWIG_From_int((int)(wxFONTENCODING_MACARMENIAN)));
23161 }
23162 {
23163 PyDict_SetItemString(d,"FONTENCODING_MACCHINESESIMP", SWIG_From_int((int)(wxFONTENCODING_MACCHINESESIMP)));
23164 }
23165 {
23166 PyDict_SetItemString(d,"FONTENCODING_MACTIBETAN", SWIG_From_int((int)(wxFONTENCODING_MACTIBETAN)));
23167 }
23168 {
23169 PyDict_SetItemString(d,"FONTENCODING_MACMONGOLIAN", SWIG_From_int((int)(wxFONTENCODING_MACMONGOLIAN)));
23170 }
23171 {
23172 PyDict_SetItemString(d,"FONTENCODING_MACETHIOPIC", SWIG_From_int((int)(wxFONTENCODING_MACETHIOPIC)));
23173 }
23174 {
23175 PyDict_SetItemString(d,"FONTENCODING_MACCENTRALEUR", SWIG_From_int((int)(wxFONTENCODING_MACCENTRALEUR)));
23176 }
23177 {
23178 PyDict_SetItemString(d,"FONTENCODING_MACVIATNAMESE", SWIG_From_int((int)(wxFONTENCODING_MACVIATNAMESE)));
23179 }
23180 {
23181 PyDict_SetItemString(d,"FONTENCODING_MACARABICEXT", SWIG_From_int((int)(wxFONTENCODING_MACARABICEXT)));
23182 }
23183 {
23184 PyDict_SetItemString(d,"FONTENCODING_MACSYMBOL", SWIG_From_int((int)(wxFONTENCODING_MACSYMBOL)));
23185 }
23186 {
23187 PyDict_SetItemString(d,"FONTENCODING_MACDINGBATS", SWIG_From_int((int)(wxFONTENCODING_MACDINGBATS)));
23188 }
23189 {
23190 PyDict_SetItemString(d,"FONTENCODING_MACTURKISH", SWIG_From_int((int)(wxFONTENCODING_MACTURKISH)));
23191 }
23192 {
23193 PyDict_SetItemString(d,"FONTENCODING_MACCROATIAN", SWIG_From_int((int)(wxFONTENCODING_MACCROATIAN)));
23194 }
23195 {
23196 PyDict_SetItemString(d,"FONTENCODING_MACICELANDIC", SWIG_From_int((int)(wxFONTENCODING_MACICELANDIC)));
23197 }
23198 {
23199 PyDict_SetItemString(d,"FONTENCODING_MACROMANIAN", SWIG_From_int((int)(wxFONTENCODING_MACROMANIAN)));
23200 }
23201 {
23202 PyDict_SetItemString(d,"FONTENCODING_MACCELTIC", SWIG_From_int((int)(wxFONTENCODING_MACCELTIC)));
23203 }
23204 {
23205 PyDict_SetItemString(d,"FONTENCODING_MACGAELIC", SWIG_From_int((int)(wxFONTENCODING_MACGAELIC)));
23206 }
23207 {
23208 PyDict_SetItemString(d,"FONTENCODING_MACKEYBOARD", SWIG_From_int((int)(wxFONTENCODING_MACKEYBOARD)));
23209 }
23210 {
23211 PyDict_SetItemString(d,"FONTENCODING_MACMIN", SWIG_From_int((int)(wxFONTENCODING_MACMIN)));
23212 }
23213 {
23214 PyDict_SetItemString(d,"FONTENCODING_MACMAX", SWIG_From_int((int)(wxFONTENCODING_MACMAX)));
23215 }
23216 {
23217 PyDict_SetItemString(d,"FONTENCODING_MAX", SWIG_From_int((int)(wxFONTENCODING_MAX)));
23218 }
23219 {
23220 PyDict_SetItemString(d,"FONTENCODING_UTF16", SWIG_From_int((int)(wxFONTENCODING_UTF16)));
23221 }
23222 {
23223 PyDict_SetItemString(d,"FONTENCODING_UTF32", SWIG_From_int((int)(wxFONTENCODING_UTF32)));
23224 }
23225 {
23226 PyDict_SetItemString(d,"FONTENCODING_UNICODE", SWIG_From_int((int)(wxFONTENCODING_UNICODE)));
23227 }
23228 {
23229 PyDict_SetItemString(d,"FONTENCODING_GB2312", SWIG_From_int((int)(wxFONTENCODING_GB2312)));
23230 }
23231 {
23232 PyDict_SetItemString(d,"FONTENCODING_BIG5", SWIG_From_int((int)(wxFONTENCODING_BIG5)));
23233 }
23234 {
23235 PyDict_SetItemString(d,"FONTENCODING_SHIFT_JIS", SWIG_From_int((int)(wxFONTENCODING_SHIFT_JIS)));
23236 }
23237
23238 wxPyPtrTypeMap_Add("wxFontEnumerator", "wxPyFontEnumerator");
23239
23240 {
23241 PyDict_SetItemString(d,"LANGUAGE_DEFAULT", SWIG_From_int((int)(wxLANGUAGE_DEFAULT)));
23242 }
23243 {
23244 PyDict_SetItemString(d,"LANGUAGE_UNKNOWN", SWIG_From_int((int)(wxLANGUAGE_UNKNOWN)));
23245 }
23246 {
23247 PyDict_SetItemString(d,"LANGUAGE_ABKHAZIAN", SWIG_From_int((int)(wxLANGUAGE_ABKHAZIAN)));
23248 }
23249 {
23250 PyDict_SetItemString(d,"LANGUAGE_AFAR", SWIG_From_int((int)(wxLANGUAGE_AFAR)));
23251 }
23252 {
23253 PyDict_SetItemString(d,"LANGUAGE_AFRIKAANS", SWIG_From_int((int)(wxLANGUAGE_AFRIKAANS)));
23254 }
23255 {
23256 PyDict_SetItemString(d,"LANGUAGE_ALBANIAN", SWIG_From_int((int)(wxLANGUAGE_ALBANIAN)));
23257 }
23258 {
23259 PyDict_SetItemString(d,"LANGUAGE_AMHARIC", SWIG_From_int((int)(wxLANGUAGE_AMHARIC)));
23260 }
23261 {
23262 PyDict_SetItemString(d,"LANGUAGE_ARABIC", SWIG_From_int((int)(wxLANGUAGE_ARABIC)));
23263 }
23264 {
23265 PyDict_SetItemString(d,"LANGUAGE_ARABIC_ALGERIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_ALGERIA)));
23266 }
23267 {
23268 PyDict_SetItemString(d,"LANGUAGE_ARABIC_BAHRAIN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_BAHRAIN)));
23269 }
23270 {
23271 PyDict_SetItemString(d,"LANGUAGE_ARABIC_EGYPT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_EGYPT)));
23272 }
23273 {
23274 PyDict_SetItemString(d,"LANGUAGE_ARABIC_IRAQ", SWIG_From_int((int)(wxLANGUAGE_ARABIC_IRAQ)));
23275 }
23276 {
23277 PyDict_SetItemString(d,"LANGUAGE_ARABIC_JORDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_JORDAN)));
23278 }
23279 {
23280 PyDict_SetItemString(d,"LANGUAGE_ARABIC_KUWAIT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_KUWAIT)));
23281 }
23282 {
23283 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LEBANON", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LEBANON)));
23284 }
23285 {
23286 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LIBYA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LIBYA)));
23287 }
23288 {
23289 PyDict_SetItemString(d,"LANGUAGE_ARABIC_MOROCCO", SWIG_From_int((int)(wxLANGUAGE_ARABIC_MOROCCO)));
23290 }
23291 {
23292 PyDict_SetItemString(d,"LANGUAGE_ARABIC_OMAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_OMAN)));
23293 }
23294 {
23295 PyDict_SetItemString(d,"LANGUAGE_ARABIC_QATAR", SWIG_From_int((int)(wxLANGUAGE_ARABIC_QATAR)));
23296 }
23297 {
23298 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SAUDI_ARABIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SAUDI_ARABIA)));
23299 }
23300 {
23301 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SUDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SUDAN)));
23302 }
23303 {
23304 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SYRIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SYRIA)));
23305 }
23306 {
23307 PyDict_SetItemString(d,"LANGUAGE_ARABIC_TUNISIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_TUNISIA)));
23308 }
23309 {
23310 PyDict_SetItemString(d,"LANGUAGE_ARABIC_UAE", SWIG_From_int((int)(wxLANGUAGE_ARABIC_UAE)));
23311 }
23312 {
23313 PyDict_SetItemString(d,"LANGUAGE_ARABIC_YEMEN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_YEMEN)));
23314 }
23315 {
23316 PyDict_SetItemString(d,"LANGUAGE_ARMENIAN", SWIG_From_int((int)(wxLANGUAGE_ARMENIAN)));
23317 }
23318 {
23319 PyDict_SetItemString(d,"LANGUAGE_ASSAMESE", SWIG_From_int((int)(wxLANGUAGE_ASSAMESE)));
23320 }
23321 {
23322 PyDict_SetItemString(d,"LANGUAGE_AYMARA", SWIG_From_int((int)(wxLANGUAGE_AYMARA)));
23323 }
23324 {
23325 PyDict_SetItemString(d,"LANGUAGE_AZERI", SWIG_From_int((int)(wxLANGUAGE_AZERI)));
23326 }
23327 {
23328 PyDict_SetItemString(d,"LANGUAGE_AZERI_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_AZERI_CYRILLIC)));
23329 }
23330 {
23331 PyDict_SetItemString(d,"LANGUAGE_AZERI_LATIN", SWIG_From_int((int)(wxLANGUAGE_AZERI_LATIN)));
23332 }
23333 {
23334 PyDict_SetItemString(d,"LANGUAGE_BASHKIR", SWIG_From_int((int)(wxLANGUAGE_BASHKIR)));
23335 }
23336 {
23337 PyDict_SetItemString(d,"LANGUAGE_BASQUE", SWIG_From_int((int)(wxLANGUAGE_BASQUE)));
23338 }
23339 {
23340 PyDict_SetItemString(d,"LANGUAGE_BELARUSIAN", SWIG_From_int((int)(wxLANGUAGE_BELARUSIAN)));
23341 }
23342 {
23343 PyDict_SetItemString(d,"LANGUAGE_BENGALI", SWIG_From_int((int)(wxLANGUAGE_BENGALI)));
23344 }
23345 {
23346 PyDict_SetItemString(d,"LANGUAGE_BHUTANI", SWIG_From_int((int)(wxLANGUAGE_BHUTANI)));
23347 }
23348 {
23349 PyDict_SetItemString(d,"LANGUAGE_BIHARI", SWIG_From_int((int)(wxLANGUAGE_BIHARI)));
23350 }
23351 {
23352 PyDict_SetItemString(d,"LANGUAGE_BISLAMA", SWIG_From_int((int)(wxLANGUAGE_BISLAMA)));
23353 }
23354 {
23355 PyDict_SetItemString(d,"LANGUAGE_BRETON", SWIG_From_int((int)(wxLANGUAGE_BRETON)));
23356 }
23357 {
23358 PyDict_SetItemString(d,"LANGUAGE_BULGARIAN", SWIG_From_int((int)(wxLANGUAGE_BULGARIAN)));
23359 }
23360 {
23361 PyDict_SetItemString(d,"LANGUAGE_BURMESE", SWIG_From_int((int)(wxLANGUAGE_BURMESE)));
23362 }
23363 {
23364 PyDict_SetItemString(d,"LANGUAGE_CAMBODIAN", SWIG_From_int((int)(wxLANGUAGE_CAMBODIAN)));
23365 }
23366 {
23367 PyDict_SetItemString(d,"LANGUAGE_CATALAN", SWIG_From_int((int)(wxLANGUAGE_CATALAN)));
23368 }
23369 {
23370 PyDict_SetItemString(d,"LANGUAGE_CHINESE", SWIG_From_int((int)(wxLANGUAGE_CHINESE)));
23371 }
23372 {
23373 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SIMPLIFIED", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SIMPLIFIED)));
23374 }
23375 {
23376 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TRADITIONAL", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TRADITIONAL)));
23377 }
23378 {
23379 PyDict_SetItemString(d,"LANGUAGE_CHINESE_HONGKONG", SWIG_From_int((int)(wxLANGUAGE_CHINESE_HONGKONG)));
23380 }
23381 {
23382 PyDict_SetItemString(d,"LANGUAGE_CHINESE_MACAU", SWIG_From_int((int)(wxLANGUAGE_CHINESE_MACAU)));
23383 }
23384 {
23385 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SINGAPORE", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SINGAPORE)));
23386 }
23387 {
23388 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TAIWAN", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TAIWAN)));
23389 }
23390 {
23391 PyDict_SetItemString(d,"LANGUAGE_CORSICAN", SWIG_From_int((int)(wxLANGUAGE_CORSICAN)));
23392 }
23393 {
23394 PyDict_SetItemString(d,"LANGUAGE_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_CROATIAN)));
23395 }
23396 {
23397 PyDict_SetItemString(d,"LANGUAGE_CZECH", SWIG_From_int((int)(wxLANGUAGE_CZECH)));
23398 }
23399 {
23400 PyDict_SetItemString(d,"LANGUAGE_DANISH", SWIG_From_int((int)(wxLANGUAGE_DANISH)));
23401 }
23402 {
23403 PyDict_SetItemString(d,"LANGUAGE_DUTCH", SWIG_From_int((int)(wxLANGUAGE_DUTCH)));
23404 }
23405 {
23406 PyDict_SetItemString(d,"LANGUAGE_DUTCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_DUTCH_BELGIAN)));
23407 }
23408 {
23409 PyDict_SetItemString(d,"LANGUAGE_ENGLISH", SWIG_From_int((int)(wxLANGUAGE_ENGLISH)));
23410 }
23411 {
23412 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_UK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_UK)));
23413 }
23414 {
23415 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_US", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_US)));
23416 }
23417 {
23418 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_AUSTRALIA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_AUSTRALIA)));
23419 }
23420 {
23421 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BELIZE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BELIZE)));
23422 }
23423 {
23424 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BOTSWANA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BOTSWANA)));
23425 }
23426 {
23427 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CANADA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CANADA)));
23428 }
23429 {
23430 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CARIBBEAN", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CARIBBEAN)));
23431 }
23432 {
23433 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_DENMARK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_DENMARK)));
23434 }
23435 {
23436 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_EIRE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_EIRE)));
23437 }
23438 {
23439 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_JAMAICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_JAMAICA)));
23440 }
23441 {
23442 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_NEW_ZEALAND", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_NEW_ZEALAND)));
23443 }
23444 {
23445 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_PHILIPPINES", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_PHILIPPINES)));
23446 }
23447 {
23448 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_SOUTH_AFRICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_SOUTH_AFRICA)));
23449 }
23450 {
23451 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_TRINIDAD", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_TRINIDAD)));
23452 }
23453 {
23454 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_ZIMBABWE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_ZIMBABWE)));
23455 }
23456 {
23457 PyDict_SetItemString(d,"LANGUAGE_ESPERANTO", SWIG_From_int((int)(wxLANGUAGE_ESPERANTO)));
23458 }
23459 {
23460 PyDict_SetItemString(d,"LANGUAGE_ESTONIAN", SWIG_From_int((int)(wxLANGUAGE_ESTONIAN)));
23461 }
23462 {
23463 PyDict_SetItemString(d,"LANGUAGE_FAEROESE", SWIG_From_int((int)(wxLANGUAGE_FAEROESE)));
23464 }
23465 {
23466 PyDict_SetItemString(d,"LANGUAGE_FARSI", SWIG_From_int((int)(wxLANGUAGE_FARSI)));
23467 }
23468 {
23469 PyDict_SetItemString(d,"LANGUAGE_FIJI", SWIG_From_int((int)(wxLANGUAGE_FIJI)));
23470 }
23471 {
23472 PyDict_SetItemString(d,"LANGUAGE_FINNISH", SWIG_From_int((int)(wxLANGUAGE_FINNISH)));
23473 }
23474 {
23475 PyDict_SetItemString(d,"LANGUAGE_FRENCH", SWIG_From_int((int)(wxLANGUAGE_FRENCH)));
23476 }
23477 {
23478 PyDict_SetItemString(d,"LANGUAGE_FRENCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_BELGIAN)));
23479 }
23480 {
23481 PyDict_SetItemString(d,"LANGUAGE_FRENCH_CANADIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_CANADIAN)));
23482 }
23483 {
23484 PyDict_SetItemString(d,"LANGUAGE_FRENCH_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_FRENCH_LUXEMBOURG)));
23485 }
23486 {
23487 PyDict_SetItemString(d,"LANGUAGE_FRENCH_MONACO", SWIG_From_int((int)(wxLANGUAGE_FRENCH_MONACO)));
23488 }
23489 {
23490 PyDict_SetItemString(d,"LANGUAGE_FRENCH_SWISS", SWIG_From_int((int)(wxLANGUAGE_FRENCH_SWISS)));
23491 }
23492 {
23493 PyDict_SetItemString(d,"LANGUAGE_FRISIAN", SWIG_From_int((int)(wxLANGUAGE_FRISIAN)));
23494 }
23495 {
23496 PyDict_SetItemString(d,"LANGUAGE_GALICIAN", SWIG_From_int((int)(wxLANGUAGE_GALICIAN)));
23497 }
23498 {
23499 PyDict_SetItemString(d,"LANGUAGE_GEORGIAN", SWIG_From_int((int)(wxLANGUAGE_GEORGIAN)));
23500 }
23501 {
23502 PyDict_SetItemString(d,"LANGUAGE_GERMAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN)));
23503 }
23504 {
23505 PyDict_SetItemString(d,"LANGUAGE_GERMAN_AUSTRIAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_AUSTRIAN)));
23506 }
23507 {
23508 PyDict_SetItemString(d,"LANGUAGE_GERMAN_BELGIUM", SWIG_From_int((int)(wxLANGUAGE_GERMAN_BELGIUM)));
23509 }
23510 {
23511 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LIECHTENSTEIN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LIECHTENSTEIN)));
23512 }
23513 {
23514 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LUXEMBOURG)));
23515 }
23516 {
23517 PyDict_SetItemString(d,"LANGUAGE_GERMAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_GERMAN_SWISS)));
23518 }
23519 {
23520 PyDict_SetItemString(d,"LANGUAGE_GREEK", SWIG_From_int((int)(wxLANGUAGE_GREEK)));
23521 }
23522 {
23523 PyDict_SetItemString(d,"LANGUAGE_GREENLANDIC", SWIG_From_int((int)(wxLANGUAGE_GREENLANDIC)));
23524 }
23525 {
23526 PyDict_SetItemString(d,"LANGUAGE_GUARANI", SWIG_From_int((int)(wxLANGUAGE_GUARANI)));
23527 }
23528 {
23529 PyDict_SetItemString(d,"LANGUAGE_GUJARATI", SWIG_From_int((int)(wxLANGUAGE_GUJARATI)));
23530 }
23531 {
23532 PyDict_SetItemString(d,"LANGUAGE_HAUSA", SWIG_From_int((int)(wxLANGUAGE_HAUSA)));
23533 }
23534 {
23535 PyDict_SetItemString(d,"LANGUAGE_HEBREW", SWIG_From_int((int)(wxLANGUAGE_HEBREW)));
23536 }
23537 {
23538 PyDict_SetItemString(d,"LANGUAGE_HINDI", SWIG_From_int((int)(wxLANGUAGE_HINDI)));
23539 }
23540 {
23541 PyDict_SetItemString(d,"LANGUAGE_HUNGARIAN", SWIG_From_int((int)(wxLANGUAGE_HUNGARIAN)));
23542 }
23543 {
23544 PyDict_SetItemString(d,"LANGUAGE_ICELANDIC", SWIG_From_int((int)(wxLANGUAGE_ICELANDIC)));
23545 }
23546 {
23547 PyDict_SetItemString(d,"LANGUAGE_INDONESIAN", SWIG_From_int((int)(wxLANGUAGE_INDONESIAN)));
23548 }
23549 {
23550 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUA", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUA)));
23551 }
23552 {
23553 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUE", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUE)));
23554 }
23555 {
23556 PyDict_SetItemString(d,"LANGUAGE_INUKTITUT", SWIG_From_int((int)(wxLANGUAGE_INUKTITUT)));
23557 }
23558 {
23559 PyDict_SetItemString(d,"LANGUAGE_INUPIAK", SWIG_From_int((int)(wxLANGUAGE_INUPIAK)));
23560 }
23561 {
23562 PyDict_SetItemString(d,"LANGUAGE_IRISH", SWIG_From_int((int)(wxLANGUAGE_IRISH)));
23563 }
23564 {
23565 PyDict_SetItemString(d,"LANGUAGE_ITALIAN", SWIG_From_int((int)(wxLANGUAGE_ITALIAN)));
23566 }
23567 {
23568 PyDict_SetItemString(d,"LANGUAGE_ITALIAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_ITALIAN_SWISS)));
23569 }
23570 {
23571 PyDict_SetItemString(d,"LANGUAGE_JAPANESE", SWIG_From_int((int)(wxLANGUAGE_JAPANESE)));
23572 }
23573 {
23574 PyDict_SetItemString(d,"LANGUAGE_JAVANESE", SWIG_From_int((int)(wxLANGUAGE_JAVANESE)));
23575 }
23576 {
23577 PyDict_SetItemString(d,"LANGUAGE_KANNADA", SWIG_From_int((int)(wxLANGUAGE_KANNADA)));
23578 }
23579 {
23580 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI)));
23581 }
23582 {
23583 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI_INDIA", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI_INDIA)));
23584 }
23585 {
23586 PyDict_SetItemString(d,"LANGUAGE_KAZAKH", SWIG_From_int((int)(wxLANGUAGE_KAZAKH)));
23587 }
23588 {
23589 PyDict_SetItemString(d,"LANGUAGE_KERNEWEK", SWIG_From_int((int)(wxLANGUAGE_KERNEWEK)));
23590 }
23591 {
23592 PyDict_SetItemString(d,"LANGUAGE_KINYARWANDA", SWIG_From_int((int)(wxLANGUAGE_KINYARWANDA)));
23593 }
23594 {
23595 PyDict_SetItemString(d,"LANGUAGE_KIRGHIZ", SWIG_From_int((int)(wxLANGUAGE_KIRGHIZ)));
23596 }
23597 {
23598 PyDict_SetItemString(d,"LANGUAGE_KIRUNDI", SWIG_From_int((int)(wxLANGUAGE_KIRUNDI)));
23599 }
23600 {
23601 PyDict_SetItemString(d,"LANGUAGE_KONKANI", SWIG_From_int((int)(wxLANGUAGE_KONKANI)));
23602 }
23603 {
23604 PyDict_SetItemString(d,"LANGUAGE_KOREAN", SWIG_From_int((int)(wxLANGUAGE_KOREAN)));
23605 }
23606 {
23607 PyDict_SetItemString(d,"LANGUAGE_KURDISH", SWIG_From_int((int)(wxLANGUAGE_KURDISH)));
23608 }
23609 {
23610 PyDict_SetItemString(d,"LANGUAGE_LAOTHIAN", SWIG_From_int((int)(wxLANGUAGE_LAOTHIAN)));
23611 }
23612 {
23613 PyDict_SetItemString(d,"LANGUAGE_LATIN", SWIG_From_int((int)(wxLANGUAGE_LATIN)));
23614 }
23615 {
23616 PyDict_SetItemString(d,"LANGUAGE_LATVIAN", SWIG_From_int((int)(wxLANGUAGE_LATVIAN)));
23617 }
23618 {
23619 PyDict_SetItemString(d,"LANGUAGE_LINGALA", SWIG_From_int((int)(wxLANGUAGE_LINGALA)));
23620 }
23621 {
23622 PyDict_SetItemString(d,"LANGUAGE_LITHUANIAN", SWIG_From_int((int)(wxLANGUAGE_LITHUANIAN)));
23623 }
23624 {
23625 PyDict_SetItemString(d,"LANGUAGE_MACEDONIAN", SWIG_From_int((int)(wxLANGUAGE_MACEDONIAN)));
23626 }
23627 {
23628 PyDict_SetItemString(d,"LANGUAGE_MALAGASY", SWIG_From_int((int)(wxLANGUAGE_MALAGASY)));
23629 }
23630 {
23631 PyDict_SetItemString(d,"LANGUAGE_MALAY", SWIG_From_int((int)(wxLANGUAGE_MALAY)));
23632 }
23633 {
23634 PyDict_SetItemString(d,"LANGUAGE_MALAYALAM", SWIG_From_int((int)(wxLANGUAGE_MALAYALAM)));
23635 }
23636 {
23637 PyDict_SetItemString(d,"LANGUAGE_MALAY_BRUNEI_DARUSSALAM", SWIG_From_int((int)(wxLANGUAGE_MALAY_BRUNEI_DARUSSALAM)));
23638 }
23639 {
23640 PyDict_SetItemString(d,"LANGUAGE_MALAY_MALAYSIA", SWIG_From_int((int)(wxLANGUAGE_MALAY_MALAYSIA)));
23641 }
23642 {
23643 PyDict_SetItemString(d,"LANGUAGE_MALTESE", SWIG_From_int((int)(wxLANGUAGE_MALTESE)));
23644 }
23645 {
23646 PyDict_SetItemString(d,"LANGUAGE_MANIPURI", SWIG_From_int((int)(wxLANGUAGE_MANIPURI)));
23647 }
23648 {
23649 PyDict_SetItemString(d,"LANGUAGE_MAORI", SWIG_From_int((int)(wxLANGUAGE_MAORI)));
23650 }
23651 {
23652 PyDict_SetItemString(d,"LANGUAGE_MARATHI", SWIG_From_int((int)(wxLANGUAGE_MARATHI)));
23653 }
23654 {
23655 PyDict_SetItemString(d,"LANGUAGE_MOLDAVIAN", SWIG_From_int((int)(wxLANGUAGE_MOLDAVIAN)));
23656 }
23657 {
23658 PyDict_SetItemString(d,"LANGUAGE_MONGOLIAN", SWIG_From_int((int)(wxLANGUAGE_MONGOLIAN)));
23659 }
23660 {
23661 PyDict_SetItemString(d,"LANGUAGE_NAURU", SWIG_From_int((int)(wxLANGUAGE_NAURU)));
23662 }
23663 {
23664 PyDict_SetItemString(d,"LANGUAGE_NEPALI", SWIG_From_int((int)(wxLANGUAGE_NEPALI)));
23665 }
23666 {
23667 PyDict_SetItemString(d,"LANGUAGE_NEPALI_INDIA", SWIG_From_int((int)(wxLANGUAGE_NEPALI_INDIA)));
23668 }
23669 {
23670 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_BOKMAL", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_BOKMAL)));
23671 }
23672 {
23673 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_NYNORSK", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_NYNORSK)));
23674 }
23675 {
23676 PyDict_SetItemString(d,"LANGUAGE_OCCITAN", SWIG_From_int((int)(wxLANGUAGE_OCCITAN)));
23677 }
23678 {
23679 PyDict_SetItemString(d,"LANGUAGE_ORIYA", SWIG_From_int((int)(wxLANGUAGE_ORIYA)));
23680 }
23681 {
23682 PyDict_SetItemString(d,"LANGUAGE_OROMO", SWIG_From_int((int)(wxLANGUAGE_OROMO)));
23683 }
23684 {
23685 PyDict_SetItemString(d,"LANGUAGE_PASHTO", SWIG_From_int((int)(wxLANGUAGE_PASHTO)));
23686 }
23687 {
23688 PyDict_SetItemString(d,"LANGUAGE_POLISH", SWIG_From_int((int)(wxLANGUAGE_POLISH)));
23689 }
23690 {
23691 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE)));
23692 }
23693 {
23694 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE_BRAZILIAN", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE_BRAZILIAN)));
23695 }
23696 {
23697 PyDict_SetItemString(d,"LANGUAGE_PUNJABI", SWIG_From_int((int)(wxLANGUAGE_PUNJABI)));
23698 }
23699 {
23700 PyDict_SetItemString(d,"LANGUAGE_QUECHUA", SWIG_From_int((int)(wxLANGUAGE_QUECHUA)));
23701 }
23702 {
23703 PyDict_SetItemString(d,"LANGUAGE_RHAETO_ROMANCE", SWIG_From_int((int)(wxLANGUAGE_RHAETO_ROMANCE)));
23704 }
23705 {
23706 PyDict_SetItemString(d,"LANGUAGE_ROMANIAN", SWIG_From_int((int)(wxLANGUAGE_ROMANIAN)));
23707 }
23708 {
23709 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN)));
23710 }
23711 {
23712 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN_UKRAINE", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN_UKRAINE)));
23713 }
23714 {
23715 PyDict_SetItemString(d,"LANGUAGE_SAMOAN", SWIG_From_int((int)(wxLANGUAGE_SAMOAN)));
23716 }
23717 {
23718 PyDict_SetItemString(d,"LANGUAGE_SANGHO", SWIG_From_int((int)(wxLANGUAGE_SANGHO)));
23719 }
23720 {
23721 PyDict_SetItemString(d,"LANGUAGE_SANSKRIT", SWIG_From_int((int)(wxLANGUAGE_SANSKRIT)));
23722 }
23723 {
23724 PyDict_SetItemString(d,"LANGUAGE_SCOTS_GAELIC", SWIG_From_int((int)(wxLANGUAGE_SCOTS_GAELIC)));
23725 }
23726 {
23727 PyDict_SetItemString(d,"LANGUAGE_SERBIAN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN)));
23728 }
23729 {
23730 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_CYRILLIC)));
23731 }
23732 {
23733 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_LATIN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_LATIN)));
23734 }
23735 {
23736 PyDict_SetItemString(d,"LANGUAGE_SERBO_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_SERBO_CROATIAN)));
23737 }
23738 {
23739 PyDict_SetItemString(d,"LANGUAGE_SESOTHO", SWIG_From_int((int)(wxLANGUAGE_SESOTHO)));
23740 }
23741 {
23742 PyDict_SetItemString(d,"LANGUAGE_SETSWANA", SWIG_From_int((int)(wxLANGUAGE_SETSWANA)));
23743 }
23744 {
23745 PyDict_SetItemString(d,"LANGUAGE_SHONA", SWIG_From_int((int)(wxLANGUAGE_SHONA)));
23746 }
23747 {
23748 PyDict_SetItemString(d,"LANGUAGE_SINDHI", SWIG_From_int((int)(wxLANGUAGE_SINDHI)));
23749 }
23750 {
23751 PyDict_SetItemString(d,"LANGUAGE_SINHALESE", SWIG_From_int((int)(wxLANGUAGE_SINHALESE)));
23752 }
23753 {
23754 PyDict_SetItemString(d,"LANGUAGE_SISWATI", SWIG_From_int((int)(wxLANGUAGE_SISWATI)));
23755 }
23756 {
23757 PyDict_SetItemString(d,"LANGUAGE_SLOVAK", SWIG_From_int((int)(wxLANGUAGE_SLOVAK)));
23758 }
23759 {
23760 PyDict_SetItemString(d,"LANGUAGE_SLOVENIAN", SWIG_From_int((int)(wxLANGUAGE_SLOVENIAN)));
23761 }
23762 {
23763 PyDict_SetItemString(d,"LANGUAGE_SOMALI", SWIG_From_int((int)(wxLANGUAGE_SOMALI)));
23764 }
23765 {
23766 PyDict_SetItemString(d,"LANGUAGE_SPANISH", SWIG_From_int((int)(wxLANGUAGE_SPANISH)));
23767 }
23768 {
23769 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ARGENTINA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ARGENTINA)));
23770 }
23771 {
23772 PyDict_SetItemString(d,"LANGUAGE_SPANISH_BOLIVIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_BOLIVIA)));
23773 }
23774 {
23775 PyDict_SetItemString(d,"LANGUAGE_SPANISH_CHILE", SWIG_From_int((int)(wxLANGUAGE_SPANISH_CHILE)));
23776 }
23777 {
23778 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COLOMBIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COLOMBIA)));
23779 }
23780 {
23781 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COSTA_RICA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COSTA_RICA)));
23782 }
23783 {
23784 PyDict_SetItemString(d,"LANGUAGE_SPANISH_DOMINICAN_REPUBLIC", SWIG_From_int((int)(wxLANGUAGE_SPANISH_DOMINICAN_REPUBLIC)));
23785 }
23786 {
23787 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ECUADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ECUADOR)));
23788 }
23789 {
23790 PyDict_SetItemString(d,"LANGUAGE_SPANISH_EL_SALVADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_EL_SALVADOR)));
23791 }
23792 {
23793 PyDict_SetItemString(d,"LANGUAGE_SPANISH_GUATEMALA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_GUATEMALA)));
23794 }
23795 {
23796 PyDict_SetItemString(d,"LANGUAGE_SPANISH_HONDURAS", SWIG_From_int((int)(wxLANGUAGE_SPANISH_HONDURAS)));
23797 }
23798 {
23799 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MEXICAN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MEXICAN)));
23800 }
23801 {
23802 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MODERN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MODERN)));
23803 }
23804 {
23805 PyDict_SetItemString(d,"LANGUAGE_SPANISH_NICARAGUA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_NICARAGUA)));
23806 }
23807 {
23808 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PANAMA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PANAMA)));
23809 }
23810 {
23811 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PARAGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PARAGUAY)));
23812 }
23813 {
23814 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PERU", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PERU)));
23815 }
23816 {
23817 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PUERTO_RICO", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PUERTO_RICO)));
23818 }
23819 {
23820 PyDict_SetItemString(d,"LANGUAGE_SPANISH_URUGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_URUGUAY)));
23821 }
23822 {
23823 PyDict_SetItemString(d,"LANGUAGE_SPANISH_US", SWIG_From_int((int)(wxLANGUAGE_SPANISH_US)));
23824 }
23825 {
23826 PyDict_SetItemString(d,"LANGUAGE_SPANISH_VENEZUELA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_VENEZUELA)));
23827 }
23828 {
23829 PyDict_SetItemString(d,"LANGUAGE_SUNDANESE", SWIG_From_int((int)(wxLANGUAGE_SUNDANESE)));
23830 }
23831 {
23832 PyDict_SetItemString(d,"LANGUAGE_SWAHILI", SWIG_From_int((int)(wxLANGUAGE_SWAHILI)));
23833 }
23834 {
23835 PyDict_SetItemString(d,"LANGUAGE_SWEDISH", SWIG_From_int((int)(wxLANGUAGE_SWEDISH)));
23836 }
23837 {
23838 PyDict_SetItemString(d,"LANGUAGE_SWEDISH_FINLAND", SWIG_From_int((int)(wxLANGUAGE_SWEDISH_FINLAND)));
23839 }
23840 {
23841 PyDict_SetItemString(d,"LANGUAGE_TAGALOG", SWIG_From_int((int)(wxLANGUAGE_TAGALOG)));
23842 }
23843 {
23844 PyDict_SetItemString(d,"LANGUAGE_TAJIK", SWIG_From_int((int)(wxLANGUAGE_TAJIK)));
23845 }
23846 {
23847 PyDict_SetItemString(d,"LANGUAGE_TAMIL", SWIG_From_int((int)(wxLANGUAGE_TAMIL)));
23848 }
23849 {
23850 PyDict_SetItemString(d,"LANGUAGE_TATAR", SWIG_From_int((int)(wxLANGUAGE_TATAR)));
23851 }
23852 {
23853 PyDict_SetItemString(d,"LANGUAGE_TELUGU", SWIG_From_int((int)(wxLANGUAGE_TELUGU)));
23854 }
23855 {
23856 PyDict_SetItemString(d,"LANGUAGE_THAI", SWIG_From_int((int)(wxLANGUAGE_THAI)));
23857 }
23858 {
23859 PyDict_SetItemString(d,"LANGUAGE_TIBETAN", SWIG_From_int((int)(wxLANGUAGE_TIBETAN)));
23860 }
23861 {
23862 PyDict_SetItemString(d,"LANGUAGE_TIGRINYA", SWIG_From_int((int)(wxLANGUAGE_TIGRINYA)));
23863 }
23864 {
23865 PyDict_SetItemString(d,"LANGUAGE_TONGA", SWIG_From_int((int)(wxLANGUAGE_TONGA)));
23866 }
23867 {
23868 PyDict_SetItemString(d,"LANGUAGE_TSONGA", SWIG_From_int((int)(wxLANGUAGE_TSONGA)));
23869 }
23870 {
23871 PyDict_SetItemString(d,"LANGUAGE_TURKISH", SWIG_From_int((int)(wxLANGUAGE_TURKISH)));
23872 }
23873 {
23874 PyDict_SetItemString(d,"LANGUAGE_TURKMEN", SWIG_From_int((int)(wxLANGUAGE_TURKMEN)));
23875 }
23876 {
23877 PyDict_SetItemString(d,"LANGUAGE_TWI", SWIG_From_int((int)(wxLANGUAGE_TWI)));
23878 }
23879 {
23880 PyDict_SetItemString(d,"LANGUAGE_UIGHUR", SWIG_From_int((int)(wxLANGUAGE_UIGHUR)));
23881 }
23882 {
23883 PyDict_SetItemString(d,"LANGUAGE_UKRAINIAN", SWIG_From_int((int)(wxLANGUAGE_UKRAINIAN)));
23884 }
23885 {
23886 PyDict_SetItemString(d,"LANGUAGE_URDU", SWIG_From_int((int)(wxLANGUAGE_URDU)));
23887 }
23888 {
23889 PyDict_SetItemString(d,"LANGUAGE_URDU_INDIA", SWIG_From_int((int)(wxLANGUAGE_URDU_INDIA)));
23890 }
23891 {
23892 PyDict_SetItemString(d,"LANGUAGE_URDU_PAKISTAN", SWIG_From_int((int)(wxLANGUAGE_URDU_PAKISTAN)));
23893 }
23894 {
23895 PyDict_SetItemString(d,"LANGUAGE_UZBEK", SWIG_From_int((int)(wxLANGUAGE_UZBEK)));
23896 }
23897 {
23898 PyDict_SetItemString(d,"LANGUAGE_UZBEK_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_UZBEK_CYRILLIC)));
23899 }
23900 {
23901 PyDict_SetItemString(d,"LANGUAGE_UZBEK_LATIN", SWIG_From_int((int)(wxLANGUAGE_UZBEK_LATIN)));
23902 }
23903 {
23904 PyDict_SetItemString(d,"LANGUAGE_VIETNAMESE", SWIG_From_int((int)(wxLANGUAGE_VIETNAMESE)));
23905 }
23906 {
23907 PyDict_SetItemString(d,"LANGUAGE_VOLAPUK", SWIG_From_int((int)(wxLANGUAGE_VOLAPUK)));
23908 }
23909 {
23910 PyDict_SetItemString(d,"LANGUAGE_WELSH", SWIG_From_int((int)(wxLANGUAGE_WELSH)));
23911 }
23912 {
23913 PyDict_SetItemString(d,"LANGUAGE_WOLOF", SWIG_From_int((int)(wxLANGUAGE_WOLOF)));
23914 }
23915 {
23916 PyDict_SetItemString(d,"LANGUAGE_XHOSA", SWIG_From_int((int)(wxLANGUAGE_XHOSA)));
23917 }
23918 {
23919 PyDict_SetItemString(d,"LANGUAGE_YIDDISH", SWIG_From_int((int)(wxLANGUAGE_YIDDISH)));
23920 }
23921 {
23922 PyDict_SetItemString(d,"LANGUAGE_YORUBA", SWIG_From_int((int)(wxLANGUAGE_YORUBA)));
23923 }
23924 {
23925 PyDict_SetItemString(d,"LANGUAGE_ZHUANG", SWIG_From_int((int)(wxLANGUAGE_ZHUANG)));
23926 }
23927 {
23928 PyDict_SetItemString(d,"LANGUAGE_ZULU", SWIG_From_int((int)(wxLANGUAGE_ZULU)));
23929 }
23930 {
23931 PyDict_SetItemString(d,"LANGUAGE_USER_DEFINED", SWIG_From_int((int)(wxLANGUAGE_USER_DEFINED)));
23932 }
23933 {
23934 PyDict_SetItemString(d,"LOCALE_CAT_NUMBER", SWIG_From_int((int)(wxLOCALE_CAT_NUMBER)));
23935 }
23936 {
23937 PyDict_SetItemString(d,"LOCALE_CAT_DATE", SWIG_From_int((int)(wxLOCALE_CAT_DATE)));
23938 }
23939 {
23940 PyDict_SetItemString(d,"LOCALE_CAT_MONEY", SWIG_From_int((int)(wxLOCALE_CAT_MONEY)));
23941 }
23942 {
23943 PyDict_SetItemString(d,"LOCALE_CAT_MAX", SWIG_From_int((int)(wxLOCALE_CAT_MAX)));
23944 }
23945 {
23946 PyDict_SetItemString(d,"LOCALE_THOUSANDS_SEP", SWIG_From_int((int)(wxLOCALE_THOUSANDS_SEP)));
23947 }
23948 {
23949 PyDict_SetItemString(d,"LOCALE_DECIMAL_POINT", SWIG_From_int((int)(wxLOCALE_DECIMAL_POINT)));
23950 }
23951 {
23952 PyDict_SetItemString(d,"LOCALE_LOAD_DEFAULT", SWIG_From_int((int)(wxLOCALE_LOAD_DEFAULT)));
23953 }
23954 {
23955 PyDict_SetItemString(d,"LOCALE_CONV_ENCODING", SWIG_From_int((int)(wxLOCALE_CONV_ENCODING)));
23956 }
23957 {
23958 PyDict_SetItemString(d,"CONVERT_STRICT", SWIG_From_int((int)(wxCONVERT_STRICT)));
23959 }
23960 {
23961 PyDict_SetItemString(d,"CONVERT_SUBSTITUTE", SWIG_From_int((int)(wxCONVERT_SUBSTITUTE)));
23962 }
23963 {
23964 PyDict_SetItemString(d,"PLATFORM_CURRENT", SWIG_From_int((int)(wxPLATFORM_CURRENT)));
23965 }
23966 {
23967 PyDict_SetItemString(d,"PLATFORM_UNIX", SWIG_From_int((int)(wxPLATFORM_UNIX)));
23968 }
23969 {
23970 PyDict_SetItemString(d,"PLATFORM_WINDOWS", SWIG_From_int((int)(wxPLATFORM_WINDOWS)));
23971 }
23972 {
23973 PyDict_SetItemString(d,"PLATFORM_OS2", SWIG_From_int((int)(wxPLATFORM_OS2)));
23974 }
23975 {
23976 PyDict_SetItemString(d,"PLATFORM_MAC", SWIG_From_int((int)(wxPLATFORM_MAC)));
23977 }
23978 {
23979 PyDict_SetItemString(d,"BUFFER_VIRTUAL_AREA", SWIG_From_int((int)(wxBUFFER_VIRTUAL_AREA)));
23980 }
23981 {
23982 PyDict_SetItemString(d,"BUFFER_CLIENT_AREA", SWIG_From_int((int)(wxBUFFER_CLIENT_AREA)));
23983 }
23984 {
23985 PyDict_SetItemString(d,"IMAGELIST_DRAW_NORMAL", SWIG_From_int((int)(wxIMAGELIST_DRAW_NORMAL)));
23986 }
23987 {
23988 PyDict_SetItemString(d,"IMAGELIST_DRAW_TRANSPARENT", SWIG_From_int((int)(wxIMAGELIST_DRAW_TRANSPARENT)));
23989 }
23990 {
23991 PyDict_SetItemString(d,"IMAGELIST_DRAW_SELECTED", SWIG_From_int((int)(wxIMAGELIST_DRAW_SELECTED)));
23992 }
23993 {
23994 PyDict_SetItemString(d,"IMAGELIST_DRAW_FOCUSED", SWIG_From_int((int)(wxIMAGELIST_DRAW_FOCUSED)));
23995 }
23996 {
23997 PyDict_SetItemString(d,"IMAGE_LIST_NORMAL", SWIG_From_int((int)(wxIMAGE_LIST_NORMAL)));
23998 }
23999 {
24000 PyDict_SetItemString(d,"IMAGE_LIST_SMALL", SWIG_From_int((int)(wxIMAGE_LIST_SMALL)));
24001 }
24002 {
24003 PyDict_SetItemString(d,"IMAGE_LIST_STATE", SWIG_From_int((int)(wxIMAGE_LIST_STATE)));
24004 }
24005 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
24006 SWIG_addvarlink(SWIG_globals,(char*)"NORMAL_FONT",_wrap_NORMAL_FONT_get, _wrap_NORMAL_FONT_set);
24007 SWIG_addvarlink(SWIG_globals,(char*)"SMALL_FONT",_wrap_SMALL_FONT_get, _wrap_SMALL_FONT_set);
24008 SWIG_addvarlink(SWIG_globals,(char*)"ITALIC_FONT",_wrap_ITALIC_FONT_get, _wrap_ITALIC_FONT_set);
24009 SWIG_addvarlink(SWIG_globals,(char*)"SWISS_FONT",_wrap_SWISS_FONT_get, _wrap_SWISS_FONT_set);
24010 SWIG_addvarlink(SWIG_globals,(char*)"RED_PEN",_wrap_RED_PEN_get, _wrap_RED_PEN_set);
24011 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_PEN",_wrap_CYAN_PEN_get, _wrap_CYAN_PEN_set);
24012 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_PEN",_wrap_GREEN_PEN_get, _wrap_GREEN_PEN_set);
24013 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_PEN",_wrap_BLACK_PEN_get, _wrap_BLACK_PEN_set);
24014 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_PEN",_wrap_WHITE_PEN_get, _wrap_WHITE_PEN_set);
24015 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_PEN",_wrap_TRANSPARENT_PEN_get, _wrap_TRANSPARENT_PEN_set);
24016 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_DASHED_PEN",_wrap_BLACK_DASHED_PEN_get, _wrap_BLACK_DASHED_PEN_set);
24017 SWIG_addvarlink(SWIG_globals,(char*)"GREY_PEN",_wrap_GREY_PEN_get, _wrap_GREY_PEN_set);
24018 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_PEN",_wrap_MEDIUM_GREY_PEN_get, _wrap_MEDIUM_GREY_PEN_set);
24019 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_PEN",_wrap_LIGHT_GREY_PEN_get, _wrap_LIGHT_GREY_PEN_set);
24020 SWIG_addvarlink(SWIG_globals,(char*)"BLUE_BRUSH",_wrap_BLUE_BRUSH_get, _wrap_BLUE_BRUSH_set);
24021 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_BRUSH",_wrap_GREEN_BRUSH_get, _wrap_GREEN_BRUSH_set);
24022 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_BRUSH",_wrap_WHITE_BRUSH_get, _wrap_WHITE_BRUSH_set);
24023 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_BRUSH",_wrap_BLACK_BRUSH_get, _wrap_BLACK_BRUSH_set);
24024 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_BRUSH",_wrap_TRANSPARENT_BRUSH_get, _wrap_TRANSPARENT_BRUSH_set);
24025 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_BRUSH",_wrap_CYAN_BRUSH_get, _wrap_CYAN_BRUSH_set);
24026 SWIG_addvarlink(SWIG_globals,(char*)"RED_BRUSH",_wrap_RED_BRUSH_get, _wrap_RED_BRUSH_set);
24027 SWIG_addvarlink(SWIG_globals,(char*)"GREY_BRUSH",_wrap_GREY_BRUSH_get, _wrap_GREY_BRUSH_set);
24028 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_BRUSH",_wrap_MEDIUM_GREY_BRUSH_get, _wrap_MEDIUM_GREY_BRUSH_set);
24029 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_BRUSH",_wrap_LIGHT_GREY_BRUSH_get, _wrap_LIGHT_GREY_BRUSH_set);
24030 SWIG_addvarlink(SWIG_globals,(char*)"BLACK",_wrap_BLACK_get, _wrap_BLACK_set);
24031 SWIG_addvarlink(SWIG_globals,(char*)"WHITE",_wrap_WHITE_get, _wrap_WHITE_set);
24032 SWIG_addvarlink(SWIG_globals,(char*)"RED",_wrap_RED_get, _wrap_RED_set);
24033 SWIG_addvarlink(SWIG_globals,(char*)"BLUE",_wrap_BLUE_get, _wrap_BLUE_set);
24034 SWIG_addvarlink(SWIG_globals,(char*)"GREEN",_wrap_GREEN_get, _wrap_GREEN_set);
24035 SWIG_addvarlink(SWIG_globals,(char*)"CYAN",_wrap_CYAN_get, _wrap_CYAN_set);
24036 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY",_wrap_LIGHT_GREY_get, _wrap_LIGHT_GREY_set);
24037 SWIG_addvarlink(SWIG_globals,(char*)"STANDARD_CURSOR",_wrap_STANDARD_CURSOR_get, _wrap_STANDARD_CURSOR_set);
24038 SWIG_addvarlink(SWIG_globals,(char*)"HOURGLASS_CURSOR",_wrap_HOURGLASS_CURSOR_get, _wrap_HOURGLASS_CURSOR_set);
24039 SWIG_addvarlink(SWIG_globals,(char*)"CROSS_CURSOR",_wrap_CROSS_CURSOR_get, _wrap_CROSS_CURSOR_set);
24040 SWIG_addvarlink(SWIG_globals,(char*)"NullBitmap",_wrap_NullBitmap_get, _wrap_NullBitmap_set);
24041 SWIG_addvarlink(SWIG_globals,(char*)"NullIcon",_wrap_NullIcon_get, _wrap_NullIcon_set);
24042 SWIG_addvarlink(SWIG_globals,(char*)"NullCursor",_wrap_NullCursor_get, _wrap_NullCursor_set);
24043 SWIG_addvarlink(SWIG_globals,(char*)"NullPen",_wrap_NullPen_get, _wrap_NullPen_set);
24044 SWIG_addvarlink(SWIG_globals,(char*)"NullBrush",_wrap_NullBrush_get, _wrap_NullBrush_set);
24045 SWIG_addvarlink(SWIG_globals,(char*)"NullPalette",_wrap_NullPalette_get, _wrap_NullPalette_set);
24046 SWIG_addvarlink(SWIG_globals,(char*)"NullFont",_wrap_NullFont_get, _wrap_NullFont_set);
24047 SWIG_addvarlink(SWIG_globals,(char*)"NullColour",_wrap_NullColour_get, _wrap_NullColour_set);
24048 SWIG_addvarlink(SWIG_globals,(char*)"TheFontList",_wrap_TheFontList_get, _wrap_TheFontList_set);
24049 SWIG_addvarlink(SWIG_globals,(char*)"ThePenList",_wrap_ThePenList_get, _wrap_ThePenList_set);
24050 SWIG_addvarlink(SWIG_globals,(char*)"TheBrushList",_wrap_TheBrushList_get, _wrap_TheBrushList_set);
24051 SWIG_addvarlink(SWIG_globals,(char*)"TheColourDatabase",_wrap_TheColourDatabase_get, _wrap_TheColourDatabase_set);
24052
24053 // Work around a chicken/egg problem in drawlist.cpp
24054 wxPyDrawList_SetAPIPtr();
24055
24056 }
24057
wxWidgets (Impactor)