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