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_new_BrushFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
3710     PyObject *resultobj;
3711     wxBitmap *arg1 = 0 ;
3712     wxBrush *result;
3713     PyObject * obj0 = 0 ;
3714     char *kwnames[] = {
3715         (char *) "stippleBitmap", NULL
3716     };
3717
3718     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BrushFromBitmap",kwnames,&obj0)) goto fail;
3719     {
3720         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3721         if (SWIG_arg_fail(1)) SWIG_fail;
3722         if (arg1 == NULL) {
3723             SWIG_null_ref("wxBitmap");
3724         }
3725         if (SWIG_arg_fail(1)) SWIG_fail;
3726     }
3727     {
3728         if (!wxPyCheckForApp()) SWIG_fail;
3729         PyThreadState* __tstate = wxPyBeginAllowThreads();
3730         result = (wxBrush *)new wxBrush((wxBitmap const &)*arg1);
3731
3732         wxPyEndAllowThreads(__tstate);
3733         if (PyErr_Occurred()) SWIG_fail;
3734     }
3735     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 1);
3736     return resultobj;
3737     fail:
3738     return NULL;
3739 }
3740
3741
3742 static PyObject *_wrap_delete_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3743     PyObject *resultobj;
3744     wxBrush *arg1 = (wxBrush *) 0 ;
3745     PyObject * obj0 = 0 ;
3746     char *kwnames[] = {
3747         (char *) "self", NULL
3748     };
3749
3750     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Brush",kwnames,&obj0)) goto fail;
3751     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3752     if (SWIG_arg_fail(1)) SWIG_fail;
3753     {
3754         PyThreadState* __tstate = wxPyBeginAllowThreads();
3755         delete arg1;
3756
3757         wxPyEndAllowThreads(__tstate);
3758         if (PyErr_Occurred()) SWIG_fail;
3759     }
3760     Py_INCREF(Py_None); resultobj = Py_None;
3761     return resultobj;
3762     fail:
3763     return NULL;
3764 }
3765
3766
3767 static PyObject *_wrap_Brush_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3768     PyObject *resultobj;
3769     wxBrush *arg1 = (wxBrush *) 0 ;
3770     wxColour *arg2 = 0 ;
3771     wxColour temp2 ;
3772     PyObject * obj0 = 0 ;
3773     PyObject * obj1 = 0 ;
3774     char *kwnames[] = {
3775         (char *) "self",(char *) "col", NULL
3776     };
3777
3778     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetColour",kwnames,&obj0,&obj1)) goto fail;
3779     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3780     if (SWIG_arg_fail(1)) SWIG_fail;
3781     {
3782         arg2 = &temp2;
3783         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3784     }
3785     {
3786         PyThreadState* __tstate = wxPyBeginAllowThreads();
3787         (arg1)->SetColour((wxColour const &)*arg2);
3788
3789         wxPyEndAllowThreads(__tstate);
3790         if (PyErr_Occurred()) SWIG_fail;
3791     }
3792     Py_INCREF(Py_None); resultobj = Py_None;
3793     return resultobj;
3794     fail:
3795     return NULL;
3796 }
3797
3798
3799 static PyObject *_wrap_Brush_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3800     PyObject *resultobj;
3801     wxBrush *arg1 = (wxBrush *) 0 ;
3802     int arg2 ;
3803     PyObject * obj0 = 0 ;
3804     PyObject * obj1 = 0 ;
3805     char *kwnames[] = {
3806         (char *) "self",(char *) "style", NULL
3807     };
3808
3809     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3810     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3811     if (SWIG_arg_fail(1)) SWIG_fail;
3812     {
3813         arg2 = (int)(SWIG_As_int(obj1));
3814         if (SWIG_arg_fail(2)) SWIG_fail;
3815     }
3816     {
3817         PyThreadState* __tstate = wxPyBeginAllowThreads();
3818         (arg1)->SetStyle(arg2);
3819
3820         wxPyEndAllowThreads(__tstate);
3821         if (PyErr_Occurred()) SWIG_fail;
3822     }
3823     Py_INCREF(Py_None); resultobj = Py_None;
3824     return resultobj;
3825     fail:
3826     return NULL;
3827 }
3828
3829
3830 static PyObject *_wrap_Brush_SetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3831     PyObject *resultobj;
3832     wxBrush *arg1 = (wxBrush *) 0 ;
3833     wxBitmap *arg2 = 0 ;
3834     PyObject * obj0 = 0 ;
3835     PyObject * obj1 = 0 ;
3836     char *kwnames[] = {
3837         (char *) "self",(char *) "stipple", NULL
3838     };
3839
3840     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStipple",kwnames,&obj0,&obj1)) goto fail;
3841     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3842     if (SWIG_arg_fail(1)) SWIG_fail;
3843     {
3844         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3845         if (SWIG_arg_fail(2)) SWIG_fail;
3846         if (arg2 == NULL) {
3847             SWIG_null_ref("wxBitmap");
3848         }
3849         if (SWIG_arg_fail(2)) SWIG_fail;
3850     }
3851     {
3852         PyThreadState* __tstate = wxPyBeginAllowThreads();
3853         (arg1)->SetStipple((wxBitmap const &)*arg2);
3854
3855         wxPyEndAllowThreads(__tstate);
3856         if (PyErr_Occurred()) SWIG_fail;
3857     }
3858     Py_INCREF(Py_None); resultobj = Py_None;
3859     return resultobj;
3860     fail:
3861     return NULL;
3862 }
3863
3864
3865 static PyObject *_wrap_Brush_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3866     PyObject *resultobj;
3867     wxBrush *arg1 = (wxBrush *) 0 ;
3868     wxColour result;
3869     PyObject * obj0 = 0 ;
3870     char *kwnames[] = {
3871         (char *) "self", NULL
3872     };
3873
3874     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetColour",kwnames,&obj0)) goto fail;
3875     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3876     if (SWIG_arg_fail(1)) SWIG_fail;
3877     {
3878         PyThreadState* __tstate = wxPyBeginAllowThreads();
3879         result = ((wxBrush const *)arg1)->GetColour();
3880
3881         wxPyEndAllowThreads(__tstate);
3882         if (PyErr_Occurred()) SWIG_fail;
3883     }
3884     {
3885         wxColour * resultptr;
3886         resultptr = new wxColour((wxColour &)(result));
3887         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3888     }
3889     return resultobj;
3890     fail:
3891     return NULL;
3892 }
3893
3894
3895 static PyObject *_wrap_Brush_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3896     PyObject *resultobj;
3897     wxBrush *arg1 = (wxBrush *) 0 ;
3898     int result;
3899     PyObject * obj0 = 0 ;
3900     char *kwnames[] = {
3901         (char *) "self", NULL
3902     };
3903
3904     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStyle",kwnames,&obj0)) goto fail;
3905     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3906     if (SWIG_arg_fail(1)) SWIG_fail;
3907     {
3908         PyThreadState* __tstate = wxPyBeginAllowThreads();
3909         result = (int)((wxBrush const *)arg1)->GetStyle();
3910
3911         wxPyEndAllowThreads(__tstate);
3912         if (PyErr_Occurred()) SWIG_fail;
3913     }
3914     {
3915         resultobj = SWIG_From_int((int)(result));
3916     }
3917     return resultobj;
3918     fail:
3919     return NULL;
3920 }
3921
3922
3923 static PyObject *_wrap_Brush_GetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3924     PyObject *resultobj;
3925     wxBrush *arg1 = (wxBrush *) 0 ;
3926     wxBitmap *result;
3927     PyObject * obj0 = 0 ;
3928     char *kwnames[] = {
3929         (char *) "self", NULL
3930     };
3931
3932     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStipple",kwnames,&obj0)) goto fail;
3933     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3934     if (SWIG_arg_fail(1)) SWIG_fail;
3935     {
3936         PyThreadState* __tstate = wxPyBeginAllowThreads();
3937         result = (wxBitmap *)((wxBrush const *)arg1)->GetStipple();
3938
3939         wxPyEndAllowThreads(__tstate);
3940         if (PyErr_Occurred()) SWIG_fail;
3941     }
3942     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 0);
3943     return resultobj;
3944     fail:
3945     return NULL;
3946 }
3947
3948
3949 static PyObject *_wrap_Brush_IsHatch(PyObject *, PyObject *args, PyObject *kwargs) {
3950     PyObject *resultobj;
3951     wxBrush *arg1 = (wxBrush *) 0 ;
3952     bool result;
3953     PyObject * obj0 = 0 ;
3954     char *kwnames[] = {
3955         (char *) "self", NULL
3956     };
3957
3958     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_IsHatch",kwnames,&obj0)) goto fail;
3959     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3960     if (SWIG_arg_fail(1)) SWIG_fail;
3961     {
3962         PyThreadState* __tstate = wxPyBeginAllowThreads();
3963         result = (bool)((wxBrush const *)arg1)->IsHatch();
3964
3965         wxPyEndAllowThreads(__tstate);
3966         if (PyErr_Occurred()) SWIG_fail;
3967     }
3968     {
3969         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3970     }
3971     return resultobj;
3972     fail:
3973     return NULL;
3974 }
3975
3976
3977 static PyObject *_wrap_Brush_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3978     PyObject *resultobj;
3979     wxBrush *arg1 = (wxBrush *) 0 ;
3980     bool result;
3981     PyObject * obj0 = 0 ;
3982     char *kwnames[] = {
3983         (char *) "self", NULL
3984     };
3985
3986     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_Ok",kwnames,&obj0)) goto fail;
3987     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3988     if (SWIG_arg_fail(1)) SWIG_fail;
3989     {
3990         PyThreadState* __tstate = wxPyBeginAllowThreads();
3991         result = (bool)(arg1)->Ok();
3992
3993         wxPyEndAllowThreads(__tstate);
3994         if (PyErr_Occurred()) SWIG_fail;
3995     }
3996     {
3997         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3998     }
3999     return resultobj;
4000     fail:
4001     return NULL;
4002 }
4003
4004
4005 static PyObject * Brush_swigregister(PyObject *, PyObject *args) {
4006     PyObject *obj;
4007     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4008     SWIG_TypeClientData(SWIGTYPE_p_wxBrush, obj);
4009     Py_INCREF(obj);
4010     return Py_BuildValue((char *)"");
4011 }
4012 static PyObject *_wrap_new_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4013     PyObject *resultobj;
4014     wxString *arg1 = 0 ;
4015     wxBitmapType arg2 = (wxBitmapType) wxBITMAP_TYPE_ANY ;
4016     wxBitmap *result;
4017     bool temp1 = false ;
4018     PyObject * obj0 = 0 ;
4019     PyObject * obj1 = 0 ;
4020     char *kwnames[] = {
4021         (char *) "name",(char *) "type", NULL
4022     };
4023
4024     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Bitmap",kwnames,&obj0,&obj1)) goto fail;
4025     {
4026         arg1 = wxString_in_helper(obj0);
4027         if (arg1 == NULL) SWIG_fail;
4028         temp1 = true;
4029     }
4030     if (obj1) {
4031         {
4032             arg2 = (wxBitmapType)(SWIG_As_int(obj1));
4033             if (SWIG_arg_fail(2)) SWIG_fail;
4034         }
4035     }
4036     {
4037         if (!wxPyCheckForApp()) SWIG_fail;
4038         PyThreadState* __tstate = wxPyBeginAllowThreads();
4039         result = (wxBitmap *)new wxBitmap((wxString const &)*arg1,(wxBitmapType )arg2);
4040
4041         wxPyEndAllowThreads(__tstate);
4042         if (PyErr_Occurred()) SWIG_fail;
4043     }
4044     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4045     {
4046         if (temp1)
4047         delete arg1;
4048     }
4049     return resultobj;
4050     fail:
4051     {
4052         if (temp1)
4053         delete arg1;
4054     }
4055     return NULL;
4056 }
4057
4058
4059 static PyObject *_wrap_delete_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4060     PyObject *resultobj;
4061     wxBitmap *arg1 = (wxBitmap *) 0 ;
4062     PyObject * obj0 = 0 ;
4063     char *kwnames[] = {
4064         (char *) "self", NULL
4065     };
4066
4067     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Bitmap",kwnames,&obj0)) goto fail;
4068     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4069     if (SWIG_arg_fail(1)) SWIG_fail;
4070     {
4071         PyThreadState* __tstate = wxPyBeginAllowThreads();
4072         delete arg1;
4073
4074         wxPyEndAllowThreads(__tstate);
4075         if (PyErr_Occurred()) SWIG_fail;
4076     }
4077     Py_INCREF(Py_None); resultobj = Py_None;
4078     return resultobj;
4079     fail:
4080     return NULL;
4081 }
4082
4083
4084 static PyObject *_wrap_new_EmptyBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4085     PyObject *resultobj;
4086     int arg1 ;
4087     int arg2 ;
4088     int arg3 = (int) -1 ;
4089     wxBitmap *result;
4090     PyObject * obj0 = 0 ;
4091     PyObject * obj1 = 0 ;
4092     PyObject * obj2 = 0 ;
4093     char *kwnames[] = {
4094         (char *) "width",(char *) "height",(char *) "depth", NULL
4095     };
4096
4097     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_EmptyBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
4098     {
4099         arg1 = (int)(SWIG_As_int(obj0));
4100         if (SWIG_arg_fail(1)) SWIG_fail;
4101     }
4102     {
4103         arg2 = (int)(SWIG_As_int(obj1));
4104         if (SWIG_arg_fail(2)) SWIG_fail;
4105     }
4106     if (obj2) {
4107         {
4108             arg3 = (int)(SWIG_As_int(obj2));
4109             if (SWIG_arg_fail(3)) SWIG_fail;
4110         }
4111     }
4112     {
4113         if (!wxPyCheckForApp()) SWIG_fail;
4114         PyThreadState* __tstate = wxPyBeginAllowThreads();
4115         result = (wxBitmap *)new wxBitmap(arg1,arg2,arg3);
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_BitmapFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4128     PyObject *resultobj;
4129     wxIcon *arg1 = 0 ;
4130     wxBitmap *result;
4131     PyObject * obj0 = 0 ;
4132     char *kwnames[] = {
4133         (char *) "icon", NULL
4134     };
4135
4136     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromIcon",kwnames,&obj0)) goto fail;
4137     {
4138         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4139         if (SWIG_arg_fail(1)) SWIG_fail;
4140         if (arg1 == NULL) {
4141             SWIG_null_ref("wxIcon");
4142         }
4143         if (SWIG_arg_fail(1)) SWIG_fail;
4144     }
4145     {
4146         if (!wxPyCheckForApp()) SWIG_fail;
4147         PyThreadState* __tstate = wxPyBeginAllowThreads();
4148         result = (wxBitmap *)new wxBitmap((wxIcon const &)*arg1);
4149
4150         wxPyEndAllowThreads(__tstate);
4151         if (PyErr_Occurred()) SWIG_fail;
4152     }
4153     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4154     return resultobj;
4155     fail:
4156     return NULL;
4157 }
4158
4159
4160 static PyObject *_wrap_new_BitmapFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
4161     PyObject *resultobj;
4162     wxImage *arg1 = 0 ;
4163     int arg2 = (int) -1 ;
4164     wxBitmap *result;
4165     PyObject * obj0 = 0 ;
4166     PyObject * obj1 = 0 ;
4167     char *kwnames[] = {
4168         (char *) "image",(char *) "depth", NULL
4169     };
4170
4171     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BitmapFromImage",kwnames,&obj0,&obj1)) goto fail;
4172     {
4173         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
4174         if (SWIG_arg_fail(1)) SWIG_fail;
4175         if (arg1 == NULL) {
4176             SWIG_null_ref("wxImage");
4177         }
4178         if (SWIG_arg_fail(1)) SWIG_fail;
4179     }
4180     if (obj1) {
4181         {
4182             arg2 = (int)(SWIG_As_int(obj1));
4183             if (SWIG_arg_fail(2)) SWIG_fail;
4184         }
4185     }
4186     {
4187         if (!wxPyCheckForApp()) SWIG_fail;
4188         PyThreadState* __tstate = wxPyBeginAllowThreads();
4189         result = (wxBitmap *)new wxBitmap((wxImage const &)*arg1,arg2);
4190
4191         wxPyEndAllowThreads(__tstate);
4192         if (PyErr_Occurred()) SWIG_fail;
4193     }
4194     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4195     return resultobj;
4196     fail:
4197     return NULL;
4198 }
4199
4200
4201 static PyObject *_wrap_new_BitmapFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
4202     PyObject *resultobj;
4203     PyObject *arg1 = (PyObject *) 0 ;
4204     wxBitmap *result;
4205     PyObject * obj0 = 0 ;
4206     char *kwnames[] = {
4207         (char *) "listOfStrings", NULL
4208     };
4209
4210     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromXPMData",kwnames,&obj0)) goto fail;
4211     arg1 = obj0;
4212     {
4213         if (!wxPyCheckForApp()) SWIG_fail;
4214         PyThreadState* __tstate = wxPyBeginAllowThreads();
4215         result = (wxBitmap *)new_wxBitmap(arg1);
4216
4217         wxPyEndAllowThreads(__tstate);
4218         if (PyErr_Occurred()) SWIG_fail;
4219     }
4220     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4221     return resultobj;
4222     fail:
4223     return NULL;
4224 }
4225
4226
4227 static PyObject *_wrap_new_BitmapFromBits(PyObject *, PyObject *args, PyObject *kwargs) {
4228     PyObject *resultobj;
4229     PyObject *arg1 = (PyObject *) 0 ;
4230     int arg2 ;
4231     int arg3 ;
4232     int arg4 = (int) 1 ;
4233     wxBitmap *result;
4234     PyObject * obj0 = 0 ;
4235     PyObject * obj1 = 0 ;
4236     PyObject * obj2 = 0 ;
4237     PyObject * obj3 = 0 ;
4238     char *kwnames[] = {
4239         (char *) "bits",(char *) "width",(char *) "height",(char *) "depth", NULL
4240     };
4241
4242     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:new_BitmapFromBits",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4243     arg1 = obj0;
4244     {
4245         arg2 = (int)(SWIG_As_int(obj1));
4246         if (SWIG_arg_fail(2)) SWIG_fail;
4247     }
4248     {
4249         arg3 = (int)(SWIG_As_int(obj2));
4250         if (SWIG_arg_fail(3)) SWIG_fail;
4251     }
4252     if (obj3) {
4253         {
4254             arg4 = (int)(SWIG_As_int(obj3));
4255             if (SWIG_arg_fail(4)) SWIG_fail;
4256         }
4257     }
4258     {
4259         if (!wxPyCheckForApp()) SWIG_fail;
4260         PyThreadState* __tstate = wxPyBeginAllowThreads();
4261         result = (wxBitmap *)new_wxBitmap(arg1,arg2,arg3,arg4);
4262
4263         wxPyEndAllowThreads(__tstate);
4264         if (PyErr_Occurred()) SWIG_fail;
4265     }
4266     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4267     return resultobj;
4268     fail:
4269     return NULL;
4270 }
4271
4272
4273 static PyObject *_wrap_Bitmap_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
4274     PyObject *resultobj;
4275     wxBitmap *arg1 = (wxBitmap *) 0 ;
4276     long result;
4277     PyObject * obj0 = 0 ;
4278     char *kwnames[] = {
4279         (char *) "self", NULL
4280     };
4281
4282     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetHandle",kwnames,&obj0)) goto fail;
4283     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4284     if (SWIG_arg_fail(1)) SWIG_fail;
4285     {
4286         PyThreadState* __tstate = wxPyBeginAllowThreads();
4287         result = (long)(arg1)->GetHandle();
4288
4289         wxPyEndAllowThreads(__tstate);
4290         if (PyErr_Occurred()) SWIG_fail;
4291     }
4292     {
4293         resultobj = SWIG_From_long((long)(result));
4294     }
4295     return resultobj;
4296     fail:
4297     return NULL;
4298 }
4299
4300
4301 static PyObject *_wrap_Bitmap_SetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
4302     PyObject *resultobj;
4303     wxBitmap *arg1 = (wxBitmap *) 0 ;
4304     long arg2 ;
4305     PyObject * obj0 = 0 ;
4306     PyObject * obj1 = 0 ;
4307     char *kwnames[] = {
4308         (char *) "self",(char *) "handle", NULL
4309     };
4310
4311     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHandle",kwnames,&obj0,&obj1)) goto fail;
4312     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4313     if (SWIG_arg_fail(1)) SWIG_fail;
4314     {
4315         arg2 = (long)(SWIG_As_long(obj1));
4316         if (SWIG_arg_fail(2)) SWIG_fail;
4317     }
4318     {
4319         PyThreadState* __tstate = wxPyBeginAllowThreads();
4320         wxBitmap_SetHandle(arg1,arg2);
4321
4322         wxPyEndAllowThreads(__tstate);
4323         if (PyErr_Occurred()) SWIG_fail;
4324     }
4325     Py_INCREF(Py_None); resultobj = Py_None;
4326     return resultobj;
4327     fail:
4328     return NULL;
4329 }
4330
4331
4332 static PyObject *_wrap_Bitmap_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
4333     PyObject *resultobj;
4334     wxBitmap *arg1 = (wxBitmap *) 0 ;
4335     bool result;
4336     PyObject * obj0 = 0 ;
4337     char *kwnames[] = {
4338         (char *) "self", NULL
4339     };
4340
4341     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_Ok",kwnames,&obj0)) goto fail;
4342     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4343     if (SWIG_arg_fail(1)) SWIG_fail;
4344     {
4345         PyThreadState* __tstate = wxPyBeginAllowThreads();
4346         result = (bool)(arg1)->Ok();
4347
4348         wxPyEndAllowThreads(__tstate);
4349         if (PyErr_Occurred()) SWIG_fail;
4350     }
4351     {
4352         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4353     }
4354     return resultobj;
4355     fail:
4356     return NULL;
4357 }
4358
4359
4360 static PyObject *_wrap_Bitmap_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4361     PyObject *resultobj;
4362     wxBitmap *arg1 = (wxBitmap *) 0 ;
4363     int result;
4364     PyObject * obj0 = 0 ;
4365     char *kwnames[] = {
4366         (char *) "self", NULL
4367     };
4368
4369     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetWidth",kwnames,&obj0)) goto fail;
4370     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4371     if (SWIG_arg_fail(1)) SWIG_fail;
4372     {
4373         PyThreadState* __tstate = wxPyBeginAllowThreads();
4374         result = (int)(arg1)->GetWidth();
4375
4376         wxPyEndAllowThreads(__tstate);
4377         if (PyErr_Occurred()) SWIG_fail;
4378     }
4379     {
4380         resultobj = SWIG_From_int((int)(result));
4381     }
4382     return resultobj;
4383     fail:
4384     return NULL;
4385 }
4386
4387
4388 static PyObject *_wrap_Bitmap_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4389     PyObject *resultobj;
4390     wxBitmap *arg1 = (wxBitmap *) 0 ;
4391     int result;
4392     PyObject * obj0 = 0 ;
4393     char *kwnames[] = {
4394         (char *) "self", NULL
4395     };
4396
4397     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetHeight",kwnames,&obj0)) goto fail;
4398     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4399     if (SWIG_arg_fail(1)) SWIG_fail;
4400     {
4401         PyThreadState* __tstate = wxPyBeginAllowThreads();
4402         result = (int)(arg1)->GetHeight();
4403
4404         wxPyEndAllowThreads(__tstate);
4405         if (PyErr_Occurred()) SWIG_fail;
4406     }
4407     {
4408         resultobj = SWIG_From_int((int)(result));
4409     }
4410     return resultobj;
4411     fail:
4412     return NULL;
4413 }
4414
4415
4416 static PyObject *_wrap_Bitmap_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4417     PyObject *resultobj;
4418     wxBitmap *arg1 = (wxBitmap *) 0 ;
4419     int result;
4420     PyObject * obj0 = 0 ;
4421     char *kwnames[] = {
4422         (char *) "self", NULL
4423     };
4424
4425     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetDepth",kwnames,&obj0)) goto fail;
4426     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4427     if (SWIG_arg_fail(1)) SWIG_fail;
4428     {
4429         PyThreadState* __tstate = wxPyBeginAllowThreads();
4430         result = (int)(arg1)->GetDepth();
4431
4432         wxPyEndAllowThreads(__tstate);
4433         if (PyErr_Occurred()) SWIG_fail;
4434     }
4435     {
4436         resultobj = SWIG_From_int((int)(result));
4437     }
4438     return resultobj;
4439     fail:
4440     return NULL;
4441 }
4442
4443
4444 static PyObject *_wrap_Bitmap_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4445     PyObject *resultobj;
4446     wxBitmap *arg1 = (wxBitmap *) 0 ;
4447     wxSize result;
4448     PyObject * obj0 = 0 ;
4449     char *kwnames[] = {
4450         (char *) "self", NULL
4451     };
4452
4453     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetSize",kwnames,&obj0)) goto fail;
4454     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4455     if (SWIG_arg_fail(1)) SWIG_fail;
4456     {
4457         PyThreadState* __tstate = wxPyBeginAllowThreads();
4458         result = wxBitmap_GetSize(arg1);
4459
4460         wxPyEndAllowThreads(__tstate);
4461         if (PyErr_Occurred()) SWIG_fail;
4462     }
4463     {
4464         wxSize * resultptr;
4465         resultptr = new wxSize((wxSize &)(result));
4466         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
4467     }
4468     return resultobj;
4469     fail:
4470     return NULL;
4471 }
4472
4473
4474 static PyObject *_wrap_Bitmap_ConvertToImage(PyObject *, PyObject *args, PyObject *kwargs) {
4475     PyObject *resultobj;
4476     wxBitmap *arg1 = (wxBitmap *) 0 ;
4477     SwigValueWrapper<wxImage > result;
4478     PyObject * obj0 = 0 ;
4479     char *kwnames[] = {
4480         (char *) "self", NULL
4481     };
4482
4483     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_ConvertToImage",kwnames,&obj0)) goto fail;
4484     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4485     if (SWIG_arg_fail(1)) SWIG_fail;
4486     {
4487         PyThreadState* __tstate = wxPyBeginAllowThreads();
4488         result = ((wxBitmap const *)arg1)->ConvertToImage();
4489
4490         wxPyEndAllowThreads(__tstate);
4491         if (PyErr_Occurred()) SWIG_fail;
4492     }
4493     {
4494         wxImage * resultptr;
4495         resultptr = new wxImage((wxImage &)(result));
4496         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
4497     }
4498     return resultobj;
4499     fail:
4500     return NULL;
4501 }
4502
4503
4504 static PyObject *_wrap_Bitmap_GetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4505     PyObject *resultobj;
4506     wxBitmap *arg1 = (wxBitmap *) 0 ;
4507     wxMask *result;
4508     PyObject * obj0 = 0 ;
4509     char *kwnames[] = {
4510         (char *) "self", NULL
4511     };
4512
4513     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetMask",kwnames,&obj0)) goto fail;
4514     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4515     if (SWIG_arg_fail(1)) SWIG_fail;
4516     {
4517         PyThreadState* __tstate = wxPyBeginAllowThreads();
4518         result = (wxMask *)((wxBitmap const *)arg1)->GetMask();
4519
4520         wxPyEndAllowThreads(__tstate);
4521         if (PyErr_Occurred()) SWIG_fail;
4522     }
4523     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 0);
4524     return resultobj;
4525     fail:
4526     return NULL;
4527 }
4528
4529
4530 static PyObject *_wrap_Bitmap_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4531     PyObject *resultobj;
4532     wxBitmap *arg1 = (wxBitmap *) 0 ;
4533     wxMask *arg2 = (wxMask *) 0 ;
4534     PyObject * obj0 = 0 ;
4535     PyObject * obj1 = 0 ;
4536     char *kwnames[] = {
4537         (char *) "self",(char *) "mask", NULL
4538     };
4539
4540     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMask",kwnames,&obj0,&obj1)) goto fail;
4541     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4542     if (SWIG_arg_fail(1)) SWIG_fail;
4543     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMask, SWIG_POINTER_EXCEPTION | 0);
4544     if (SWIG_arg_fail(2)) SWIG_fail;
4545     {
4546         PyThreadState* __tstate = wxPyBeginAllowThreads();
4547         (arg1)->SetMask(arg2);
4548
4549         wxPyEndAllowThreads(__tstate);
4550         if (PyErr_Occurred()) SWIG_fail;
4551     }
4552     Py_INCREF(Py_None); resultobj = Py_None;
4553     return resultobj;
4554     fail:
4555     return NULL;
4556 }
4557
4558
4559 static PyObject *_wrap_Bitmap_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
4560     PyObject *resultobj;
4561     wxBitmap *arg1 = (wxBitmap *) 0 ;
4562     wxColour *arg2 = 0 ;
4563     wxColour temp2 ;
4564     PyObject * obj0 = 0 ;
4565     PyObject * obj1 = 0 ;
4566     char *kwnames[] = {
4567         (char *) "self",(char *) "colour", NULL
4568     };
4569
4570     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMaskColour",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 ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4576     }
4577     {
4578         PyThreadState* __tstate = wxPyBeginAllowThreads();
4579         wxBitmap_SetMaskColour(arg1,(wxColour const &)*arg2);
4580
4581         wxPyEndAllowThreads(__tstate);
4582         if (PyErr_Occurred()) SWIG_fail;
4583     }
4584     Py_INCREF(Py_None); resultobj = Py_None;
4585     return resultobj;
4586     fail:
4587     return NULL;
4588 }
4589
4590
4591 static PyObject *_wrap_Bitmap_GetSubBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4592     PyObject *resultobj;
4593     wxBitmap *arg1 = (wxBitmap *) 0 ;
4594     wxRect *arg2 = 0 ;
4595     SwigValueWrapper<wxBitmap > result;
4596     wxRect temp2 ;
4597     PyObject * obj0 = 0 ;
4598     PyObject * obj1 = 0 ;
4599     char *kwnames[] = {
4600         (char *) "self",(char *) "rect", NULL
4601     };
4602
4603     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_GetSubBitmap",kwnames,&obj0,&obj1)) goto fail;
4604     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4605     if (SWIG_arg_fail(1)) SWIG_fail;
4606     {
4607         arg2 = &temp2;
4608         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4609     }
4610     {
4611         PyThreadState* __tstate = wxPyBeginAllowThreads();
4612         result = ((wxBitmap const *)arg1)->GetSubBitmap((wxRect const &)*arg2);
4613
4614         wxPyEndAllowThreads(__tstate);
4615         if (PyErr_Occurred()) SWIG_fail;
4616     }
4617     {
4618         wxBitmap * resultptr;
4619         resultptr = new wxBitmap((wxBitmap &)(result));
4620         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
4621     }
4622     return resultobj;
4623     fail:
4624     return NULL;
4625 }
4626
4627
4628 static PyObject *_wrap_Bitmap_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
4629     PyObject *resultobj;
4630     wxBitmap *arg1 = (wxBitmap *) 0 ;
4631     wxString *arg2 = 0 ;
4632     wxBitmapType arg3 ;
4633     wxPalette *arg4 = (wxPalette *) NULL ;
4634     bool result;
4635     bool temp2 = false ;
4636     PyObject * obj0 = 0 ;
4637     PyObject * obj1 = 0 ;
4638     PyObject * obj2 = 0 ;
4639     PyObject * obj3 = 0 ;
4640     char *kwnames[] = {
4641         (char *) "self",(char *) "name",(char *) "type",(char *) "palette", NULL
4642     };
4643
4644     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Bitmap_SaveFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4645     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4646     if (SWIG_arg_fail(1)) SWIG_fail;
4647     {
4648         arg2 = wxString_in_helper(obj1);
4649         if (arg2 == NULL) SWIG_fail;
4650         temp2 = true;
4651     }
4652     {
4653         arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4654         if (SWIG_arg_fail(3)) SWIG_fail;
4655     }
4656     if (obj3) {
4657         SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
4658         if (SWIG_arg_fail(4)) SWIG_fail;
4659     }
4660     {
4661         PyThreadState* __tstate = wxPyBeginAllowThreads();
4662         result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxBitmapType )arg3,arg4);
4663
4664         wxPyEndAllowThreads(__tstate);
4665         if (PyErr_Occurred()) SWIG_fail;
4666     }
4667     {
4668         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4669     }
4670     {
4671         if (temp2)
4672         delete arg2;
4673     }
4674     return resultobj;
4675     fail:
4676     {
4677         if (temp2)
4678         delete arg2;
4679     }
4680     return NULL;
4681 }
4682
4683
4684 static PyObject *_wrap_Bitmap_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
4685     PyObject *resultobj;
4686     wxBitmap *arg1 = (wxBitmap *) 0 ;
4687     wxString *arg2 = 0 ;
4688     wxBitmapType arg3 ;
4689     bool result;
4690     bool temp2 = false ;
4691     PyObject * obj0 = 0 ;
4692     PyObject * obj1 = 0 ;
4693     PyObject * obj2 = 0 ;
4694     char *kwnames[] = {
4695         (char *) "self",(char *) "name",(char *) "type", NULL
4696     };
4697
4698     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Bitmap_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
4699     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4700     if (SWIG_arg_fail(1)) SWIG_fail;
4701     {
4702         arg2 = wxString_in_helper(obj1);
4703         if (arg2 == NULL) SWIG_fail;
4704         temp2 = true;
4705     }
4706     {
4707         arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4708         if (SWIG_arg_fail(3)) SWIG_fail;
4709     }
4710     {
4711         PyThreadState* __tstate = wxPyBeginAllowThreads();
4712         result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
4713
4714         wxPyEndAllowThreads(__tstate);
4715         if (PyErr_Occurred()) SWIG_fail;
4716     }
4717     {
4718         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4719     }
4720     {
4721         if (temp2)
4722         delete arg2;
4723     }
4724     return resultobj;
4725     fail:
4726     {
4727         if (temp2)
4728         delete arg2;
4729     }
4730     return NULL;
4731 }
4732
4733
4734 static PyObject *_wrap_Bitmap_GetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
4735     PyObject *resultobj;
4736     wxBitmap *arg1 = (wxBitmap *) 0 ;
4737     wxPalette *result;
4738     PyObject * obj0 = 0 ;
4739     char *kwnames[] = {
4740         (char *) "self", NULL
4741     };
4742
4743     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetPalette",kwnames,&obj0)) goto fail;
4744     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4745     if (SWIG_arg_fail(1)) SWIG_fail;
4746     {
4747         PyThreadState* __tstate = wxPyBeginAllowThreads();
4748         result = (wxPalette *)((wxBitmap const *)arg1)->GetPalette();
4749
4750         wxPyEndAllowThreads(__tstate);
4751         if (PyErr_Occurred()) SWIG_fail;
4752     }
4753     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 0);
4754     return resultobj;
4755     fail:
4756     return NULL;
4757 }
4758
4759
4760 static PyObject *_wrap_Bitmap_SetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
4761     PyObject *resultobj;
4762     wxBitmap *arg1 = (wxBitmap *) 0 ;
4763     wxPalette *arg2 = 0 ;
4764     PyObject * obj0 = 0 ;
4765     PyObject * obj1 = 0 ;
4766     char *kwnames[] = {
4767         (char *) "self",(char *) "palette", NULL
4768     };
4769
4770     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetPalette",kwnames,&obj0,&obj1)) goto fail;
4771     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4772     if (SWIG_arg_fail(1)) SWIG_fail;
4773     {
4774         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
4775         if (SWIG_arg_fail(2)) SWIG_fail;
4776         if (arg2 == NULL) {
4777             SWIG_null_ref("wxPalette");
4778         }
4779         if (SWIG_arg_fail(2)) SWIG_fail;
4780     }
4781     {
4782         PyThreadState* __tstate = wxPyBeginAllowThreads();
4783         (arg1)->SetPalette((wxPalette const &)*arg2);
4784
4785         wxPyEndAllowThreads(__tstate);
4786         if (PyErr_Occurred()) SWIG_fail;
4787     }
4788     Py_INCREF(Py_None); resultobj = Py_None;
4789     return resultobj;
4790     fail:
4791     return NULL;
4792 }
4793
4794
4795 static PyObject *_wrap_Bitmap_CopyFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4796     PyObject *resultobj;
4797     wxBitmap *arg1 = (wxBitmap *) 0 ;
4798     wxIcon *arg2 = 0 ;
4799     bool result;
4800     PyObject * obj0 = 0 ;
4801     PyObject * obj1 = 0 ;
4802     char *kwnames[] = {
4803         (char *) "self",(char *) "icon", NULL
4804     };
4805
4806     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromIcon",kwnames,&obj0,&obj1)) goto fail;
4807     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4808     if (SWIG_arg_fail(1)) SWIG_fail;
4809     {
4810         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4811         if (SWIG_arg_fail(2)) SWIG_fail;
4812         if (arg2 == NULL) {
4813             SWIG_null_ref("wxIcon");
4814         }
4815         if (SWIG_arg_fail(2)) SWIG_fail;
4816     }
4817     {
4818         PyThreadState* __tstate = wxPyBeginAllowThreads();
4819         result = (bool)(arg1)->CopyFromIcon((wxIcon const &)*arg2);
4820
4821         wxPyEndAllowThreads(__tstate);
4822         if (PyErr_Occurred()) SWIG_fail;
4823     }
4824     {
4825         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4826     }
4827     return resultobj;
4828     fail:
4829     return NULL;
4830 }
4831
4832
4833 static PyObject *_wrap_Bitmap_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4834     PyObject *resultobj;
4835     wxBitmap *arg1 = (wxBitmap *) 0 ;
4836     int arg2 ;
4837     PyObject * obj0 = 0 ;
4838     PyObject * obj1 = 0 ;
4839     char *kwnames[] = {
4840         (char *) "self",(char *) "height", NULL
4841     };
4842
4843     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHeight",kwnames,&obj0,&obj1)) goto fail;
4844     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4845     if (SWIG_arg_fail(1)) SWIG_fail;
4846     {
4847         arg2 = (int)(SWIG_As_int(obj1));
4848         if (SWIG_arg_fail(2)) SWIG_fail;
4849     }
4850     {
4851         PyThreadState* __tstate = wxPyBeginAllowThreads();
4852         (arg1)->SetHeight(arg2);
4853
4854         wxPyEndAllowThreads(__tstate);
4855         if (PyErr_Occurred()) SWIG_fail;
4856     }
4857     Py_INCREF(Py_None); resultobj = Py_None;
4858     return resultobj;
4859     fail:
4860     return NULL;
4861 }
4862
4863
4864 static PyObject *_wrap_Bitmap_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4865     PyObject *resultobj;
4866     wxBitmap *arg1 = (wxBitmap *) 0 ;
4867     int arg2 ;
4868     PyObject * obj0 = 0 ;
4869     PyObject * obj1 = 0 ;
4870     char *kwnames[] = {
4871         (char *) "self",(char *) "width", NULL
4872     };
4873
4874     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetWidth",kwnames,&obj0,&obj1)) goto fail;
4875     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4876     if (SWIG_arg_fail(1)) SWIG_fail;
4877     {
4878         arg2 = (int)(SWIG_As_int(obj1));
4879         if (SWIG_arg_fail(2)) SWIG_fail;
4880     }
4881     {
4882         PyThreadState* __tstate = wxPyBeginAllowThreads();
4883         (arg1)->SetWidth(arg2);
4884
4885         wxPyEndAllowThreads(__tstate);
4886         if (PyErr_Occurred()) SWIG_fail;
4887     }
4888     Py_INCREF(Py_None); resultobj = Py_None;
4889     return resultobj;
4890     fail:
4891     return NULL;
4892 }
4893
4894
4895 static PyObject *_wrap_Bitmap_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4896     PyObject *resultobj;
4897     wxBitmap *arg1 = (wxBitmap *) 0 ;
4898     int arg2 ;
4899     PyObject * obj0 = 0 ;
4900     PyObject * obj1 = 0 ;
4901     char *kwnames[] = {
4902         (char *) "self",(char *) "depth", NULL
4903     };
4904
4905     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetDepth",kwnames,&obj0,&obj1)) goto fail;
4906     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4907     if (SWIG_arg_fail(1)) SWIG_fail;
4908     {
4909         arg2 = (int)(SWIG_As_int(obj1));
4910         if (SWIG_arg_fail(2)) SWIG_fail;
4911     }
4912     {
4913         PyThreadState* __tstate = wxPyBeginAllowThreads();
4914         (arg1)->SetDepth(arg2);
4915
4916         wxPyEndAllowThreads(__tstate);
4917         if (PyErr_Occurred()) SWIG_fail;
4918     }
4919     Py_INCREF(Py_None); resultobj = Py_None;
4920     return resultobj;
4921     fail:
4922     return NULL;
4923 }
4924
4925
4926 static PyObject *_wrap_Bitmap_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4927     PyObject *resultobj;
4928     wxBitmap *arg1 = (wxBitmap *) 0 ;
4929     wxSize *arg2 = 0 ;
4930     wxSize temp2 ;
4931     PyObject * obj0 = 0 ;
4932     PyObject * obj1 = 0 ;
4933     char *kwnames[] = {
4934         (char *) "self",(char *) "size", NULL
4935     };
4936
4937     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetSize",kwnames,&obj0,&obj1)) goto fail;
4938     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4939     if (SWIG_arg_fail(1)) SWIG_fail;
4940     {
4941         arg2 = &temp2;
4942         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4943     }
4944     {
4945         PyThreadState* __tstate = wxPyBeginAllowThreads();
4946         wxBitmap_SetSize(arg1,(wxSize const &)*arg2);
4947
4948         wxPyEndAllowThreads(__tstate);
4949         if (PyErr_Occurred()) SWIG_fail;
4950     }
4951     Py_INCREF(Py_None); resultobj = Py_None;
4952     return resultobj;
4953     fail:
4954     return NULL;
4955 }
4956
4957
4958 static PyObject *_wrap_Bitmap_CopyFromCursor(PyObject *, PyObject *args, PyObject *kwargs) {
4959     PyObject *resultobj;
4960     wxBitmap *arg1 = (wxBitmap *) 0 ;
4961     wxCursor *arg2 = 0 ;
4962     bool result;
4963     PyObject * obj0 = 0 ;
4964     PyObject * obj1 = 0 ;
4965     char *kwnames[] = {
4966         (char *) "self",(char *) "cursor", NULL
4967     };
4968
4969     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromCursor",kwnames,&obj0,&obj1)) goto fail;
4970     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4971     if (SWIG_arg_fail(1)) SWIG_fail;
4972     {
4973         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
4974         if (SWIG_arg_fail(2)) SWIG_fail;
4975         if (arg2 == NULL) {
4976             SWIG_null_ref("wxCursor");
4977         }
4978         if (SWIG_arg_fail(2)) SWIG_fail;
4979     }
4980     {
4981         PyThreadState* __tstate = wxPyBeginAllowThreads();
4982         result = (bool)(arg1)->CopyFromCursor((wxCursor const &)*arg2);
4983
4984         wxPyEndAllowThreads(__tstate);
4985         if (PyErr_Occurred()) SWIG_fail;
4986     }
4987     {
4988         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4989     }
4990     return resultobj;
4991     fail:
4992     return NULL;
4993 }
4994
4995
4996 static PyObject *_wrap_Bitmap_GetQuality(PyObject *, PyObject *args, PyObject *kwargs) {
4997     PyObject *resultobj;
4998     wxBitmap *arg1 = (wxBitmap *) 0 ;
4999     int result;
5000     PyObject * obj0 = 0 ;
5001     char *kwnames[] = {
5002         (char *) "self", NULL
5003     };
5004
5005     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetQuality",kwnames,&obj0)) goto fail;
5006     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5007     if (SWIG_arg_fail(1)) SWIG_fail;
5008     {
5009         PyThreadState* __tstate = wxPyBeginAllowThreads();
5010         result = (int)(arg1)->GetQuality();
5011
5012         wxPyEndAllowThreads(__tstate);
5013         if (PyErr_Occurred()) SWIG_fail;
5014     }
5015     {
5016         resultobj = SWIG_From_int((int)(result));
5017     }
5018     return resultobj;
5019     fail:
5020     return NULL;
5021 }
5022
5023
5024 static PyObject *_wrap_Bitmap_SetQuality(PyObject *, PyObject *args, PyObject *kwargs) {
5025     PyObject *resultobj;
5026     wxBitmap *arg1 = (wxBitmap *) 0 ;
5027     int arg2 ;
5028     PyObject * obj0 = 0 ;
5029     PyObject * obj1 = 0 ;
5030     char *kwnames[] = {
5031         (char *) "self",(char *) "q", NULL
5032     };
5033
5034     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetQuality",kwnames,&obj0,&obj1)) goto fail;
5035     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5036     if (SWIG_arg_fail(1)) SWIG_fail;
5037     {
5038         arg2 = (int)(SWIG_As_int(obj1));
5039         if (SWIG_arg_fail(2)) SWIG_fail;
5040     }
5041     {
5042         PyThreadState* __tstate = wxPyBeginAllowThreads();
5043         (arg1)->SetQuality(arg2);
5044
5045         wxPyEndAllowThreads(__tstate);
5046         if (PyErr_Occurred()) SWIG_fail;
5047     }
5048     Py_INCREF(Py_None); resultobj = Py_None;
5049     return resultobj;
5050     fail:
5051     return NULL;
5052 }
5053
5054
5055 static PyObject *_wrap_Bitmap___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5056     PyObject *resultobj;
5057     wxBitmap *arg1 = (wxBitmap *) 0 ;
5058     wxBitmap *arg2 = (wxBitmap *) 0 ;
5059     bool result;
5060     PyObject * obj0 = 0 ;
5061     PyObject * obj1 = 0 ;
5062     char *kwnames[] = {
5063         (char *) "self",(char *) "other", NULL
5064     };
5065
5066     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___eq__",kwnames,&obj0,&obj1)) goto fail;
5067     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5068     if (SWIG_arg_fail(1)) SWIG_fail;
5069     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5070     if (SWIG_arg_fail(2)) SWIG_fail;
5071     {
5072         PyThreadState* __tstate = wxPyBeginAllowThreads();
5073         result = (bool)wxBitmap___eq__(arg1,(wxBitmap const *)arg2);
5074
5075         wxPyEndAllowThreads(__tstate);
5076         if (PyErr_Occurred()) SWIG_fail;
5077     }
5078     {
5079         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5080     }
5081     return resultobj;
5082     fail:
5083     return NULL;
5084 }
5085
5086
5087 static PyObject *_wrap_Bitmap___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
5088     PyObject *resultobj;
5089     wxBitmap *arg1 = (wxBitmap *) 0 ;
5090     wxBitmap *arg2 = (wxBitmap *) 0 ;
5091     bool result;
5092     PyObject * obj0 = 0 ;
5093     PyObject * obj1 = 0 ;
5094     char *kwnames[] = {
5095         (char *) "self",(char *) "other", NULL
5096     };
5097
5098     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___ne__",kwnames,&obj0,&obj1)) goto fail;
5099     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5100     if (SWIG_arg_fail(1)) SWIG_fail;
5101     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5102     if (SWIG_arg_fail(2)) SWIG_fail;
5103     {
5104         PyThreadState* __tstate = wxPyBeginAllowThreads();
5105         result = (bool)wxBitmap___ne__(arg1,(wxBitmap const *)arg2);
5106
5107         wxPyEndAllowThreads(__tstate);
5108         if (PyErr_Occurred()) SWIG_fail;
5109     }
5110     {
5111         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5112     }
5113     return resultobj;
5114     fail:
5115     return NULL;
5116 }
5117
5118
5119 static PyObject * Bitmap_swigregister(PyObject *, PyObject *args) {
5120     PyObject *obj;
5121     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5122     SWIG_TypeClientData(SWIGTYPE_p_wxBitmap, obj);
5123     Py_INCREF(obj);
5124     return Py_BuildValue((char *)"");
5125 }
5126 static PyObject *_wrap_new_Mask(PyObject *, PyObject *args, PyObject *kwargs) {
5127     PyObject *resultobj;
5128     wxBitmap *arg1 = 0 ;
5129     wxColour const &arg2_defvalue = wxNullColour ;
5130     wxColour *arg2 = (wxColour *) &arg2_defvalue ;
5131     wxMask *result;
5132     wxColour temp2 ;
5133     PyObject * obj0 = 0 ;
5134     PyObject * obj1 = 0 ;
5135     char *kwnames[] = {
5136         (char *) "bitmap",(char *) "colour", NULL
5137     };
5138
5139     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Mask",kwnames,&obj0,&obj1)) goto fail;
5140     {
5141         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5142         if (SWIG_arg_fail(1)) SWIG_fail;
5143         if (arg1 == NULL) {
5144             SWIG_null_ref("wxBitmap");
5145         }
5146         if (SWIG_arg_fail(1)) SWIG_fail;
5147     }
5148     if (obj1) {
5149         {
5150             arg2 = &temp2;
5151             if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5152         }
5153     }
5154     {
5155         if (!wxPyCheckForApp()) SWIG_fail;
5156         PyThreadState* __tstate = wxPyBeginAllowThreads();
5157         result = (wxMask *)new_wxMask((wxBitmap const &)*arg1,(wxColour const &)*arg2);
5158
5159         wxPyEndAllowThreads(__tstate);
5160         if (PyErr_Occurred()) SWIG_fail;
5161     }
5162     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 1);
5163     return resultobj;
5164     fail:
5165     return NULL;
5166 }
5167
5168
5169 static PyObject * Mask_swigregister(PyObject *, PyObject *args) {
5170     PyObject *obj;
5171     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5172     SWIG_TypeClientData(SWIGTYPE_p_wxMask, obj);
5173     Py_INCREF(obj);
5174     return Py_BuildValue((char *)"");
5175 }
5176 static PyObject *_wrap_new_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
5177     PyObject *resultobj;
5178     wxString *arg1 = 0 ;
5179     wxBitmapType arg2 ;
5180     int arg3 = (int) -1 ;
5181     int arg4 = (int) -1 ;
5182     wxIcon *result;
5183     bool temp1 = false ;
5184     PyObject * obj0 = 0 ;
5185     PyObject * obj1 = 0 ;
5186     PyObject * obj2 = 0 ;
5187     PyObject * obj3 = 0 ;
5188     char *kwnames[] = {
5189         (char *) "name",(char *) "type",(char *) "desiredWidth",(char *) "desiredHeight", NULL
5190     };
5191
5192     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Icon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5193     {
5194         arg1 = wxString_in_helper(obj0);
5195         if (arg1 == NULL) SWIG_fail;
5196         temp1 = true;
5197     }
5198     {
5199         arg2 = (wxBitmapType)(SWIG_As_int(obj1));
5200         if (SWIG_arg_fail(2)) SWIG_fail;
5201     }
5202     if (obj2) {
5203         {
5204             arg3 = (int)(SWIG_As_int(obj2));
5205             if (SWIG_arg_fail(3)) SWIG_fail;
5206         }
5207     }
5208     if (obj3) {
5209         {
5210             arg4 = (int)(SWIG_As_int(obj3));
5211             if (SWIG_arg_fail(4)) SWIG_fail;
5212         }
5213     }
5214     {
5215         if (!wxPyCheckForApp()) SWIG_fail;
5216         PyThreadState* __tstate = wxPyBeginAllowThreads();
5217         result = (wxIcon *)new wxIcon((wxString const &)*arg1,(wxBitmapType )arg2,arg3,arg4);
5218
5219         wxPyEndAllowThreads(__tstate);
5220         if (PyErr_Occurred()) SWIG_fail;
5221     }
5222     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5223     {
5224         if (temp1)
5225         delete arg1;
5226     }
5227     return resultobj;
5228     fail:
5229     {
5230         if (temp1)
5231         delete arg1;
5232     }
5233     return NULL;
5234 }
5235
5236
5237 static PyObject *_wrap_delete_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
5238     PyObject *resultobj;
5239     wxIcon *arg1 = (wxIcon *) 0 ;
5240     PyObject * obj0 = 0 ;
5241     char *kwnames[] = {
5242         (char *) "self", NULL
5243     };
5244
5245     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Icon",kwnames,&obj0)) goto fail;
5246     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5247     if (SWIG_arg_fail(1)) SWIG_fail;
5248     {
5249         PyThreadState* __tstate = wxPyBeginAllowThreads();
5250         delete arg1;
5251
5252         wxPyEndAllowThreads(__tstate);
5253         if (PyErr_Occurred()) SWIG_fail;
5254     }
5255     Py_INCREF(Py_None); resultobj = Py_None;
5256     return resultobj;
5257     fail:
5258     return NULL;
5259 }
5260
5261
5262 static PyObject *_wrap_new_EmptyIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5263     PyObject *resultobj;
5264     wxIcon *result;
5265     char *kwnames[] = {
5266         NULL
5267     };
5268
5269     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EmptyIcon",kwnames)) goto fail;
5270     {
5271         if (!wxPyCheckForApp()) SWIG_fail;
5272         PyThreadState* __tstate = wxPyBeginAllowThreads();
5273         result = (wxIcon *)new wxIcon();
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_IconFromLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5286     PyObject *resultobj;
5287     wxIconLocation *arg1 = 0 ;
5288     wxIcon *result;
5289     PyObject * obj0 = 0 ;
5290     char *kwnames[] = {
5291         (char *) "loc", NULL
5292     };
5293
5294     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromLocation",kwnames,&obj0)) goto fail;
5295     {
5296         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5297         if (SWIG_arg_fail(1)) SWIG_fail;
5298         if (arg1 == NULL) {
5299             SWIG_null_ref("wxIconLocation");
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((wxIconLocation 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_IconFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5319     PyObject *resultobj;
5320     wxBitmap *arg1 = 0 ;
5321     wxIcon *result;
5322     PyObject * obj0 = 0 ;
5323     char *kwnames[] = {
5324         (char *) "bmp", NULL
5325     };
5326
5327     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromBitmap",kwnames,&obj0)) goto fail;
5328     {
5329         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5330         if (SWIG_arg_fail(1)) SWIG_fail;
5331         if (arg1 == NULL) {
5332             SWIG_null_ref("wxBitmap");
5333         }
5334         if (SWIG_arg_fail(1)) SWIG_fail;
5335     }
5336     {
5337         if (!wxPyCheckForApp()) SWIG_fail;
5338         PyThreadState* __tstate = wxPyBeginAllowThreads();
5339         result = (wxIcon *)new_wxIcon((wxBitmap const &)*arg1);
5340
5341         wxPyEndAllowThreads(__tstate);
5342         if (PyErr_Occurred()) SWIG_fail;
5343     }
5344     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5345     return resultobj;
5346     fail:
5347     return NULL;
5348 }
5349
5350
5351 static PyObject *_wrap_new_IconFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
5352     PyObject *resultobj;
5353     PyObject *arg1 = (PyObject *) 0 ;
5354     wxIcon *result;
5355     PyObject * obj0 = 0 ;
5356     char *kwnames[] = {
5357         (char *) "listOfStrings", NULL
5358     };
5359
5360     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromXPMData",kwnames,&obj0)) goto fail;
5361     arg1 = obj0;
5362     {
5363         if (!wxPyCheckForApp()) SWIG_fail;
5364         PyThreadState* __tstate = wxPyBeginAllowThreads();
5365         result = (wxIcon *)new_wxIcon(arg1);
5366
5367         wxPyEndAllowThreads(__tstate);
5368         if (PyErr_Occurred()) SWIG_fail;
5369     }
5370     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5371     return resultobj;
5372     fail:
5373     return NULL;
5374 }
5375
5376
5377 static PyObject *_wrap_Icon_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
5378     PyObject *resultobj;
5379     wxIcon *arg1 = (wxIcon *) 0 ;
5380     wxString *arg2 = 0 ;
5381     wxBitmapType arg3 ;
5382     bool result;
5383     bool temp2 = false ;
5384     PyObject * obj0 = 0 ;
5385     PyObject * obj1 = 0 ;
5386     PyObject * obj2 = 0 ;
5387     char *kwnames[] = {
5388         (char *) "self",(char *) "name",(char *) "type", NULL
5389     };
5390
5391     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Icon_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
5392     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5393     if (SWIG_arg_fail(1)) SWIG_fail;
5394     {
5395         arg2 = wxString_in_helper(obj1);
5396         if (arg2 == NULL) SWIG_fail;
5397         temp2 = true;
5398     }
5399     {
5400         arg3 = (wxBitmapType)(SWIG_As_int(obj2));
5401         if (SWIG_arg_fail(3)) SWIG_fail;
5402     }
5403     {
5404         PyThreadState* __tstate = wxPyBeginAllowThreads();
5405         result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
5406
5407         wxPyEndAllowThreads(__tstate);
5408         if (PyErr_Occurred()) SWIG_fail;
5409     }
5410     {
5411         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5412     }
5413     {
5414         if (temp2)
5415         delete arg2;
5416     }
5417     return resultobj;
5418     fail:
5419     {
5420         if (temp2)
5421         delete arg2;
5422     }
5423     return NULL;
5424 }
5425
5426
5427 static PyObject *_wrap_Icon_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
5428     PyObject *resultobj;
5429     wxIcon *arg1 = (wxIcon *) 0 ;
5430     long result;
5431     PyObject * obj0 = 0 ;
5432     char *kwnames[] = {
5433         (char *) "self", NULL
5434     };
5435
5436     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetHandle",kwnames,&obj0)) goto fail;
5437     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5438     if (SWIG_arg_fail(1)) SWIG_fail;
5439     {
5440         PyThreadState* __tstate = wxPyBeginAllowThreads();
5441         result = (long)(arg1)->GetHandle();
5442
5443         wxPyEndAllowThreads(__tstate);
5444         if (PyErr_Occurred()) SWIG_fail;
5445     }
5446     {
5447         resultobj = SWIG_From_long((long)(result));
5448     }
5449     return resultobj;
5450     fail:
5451     return NULL;
5452 }
5453
5454
5455 static PyObject *_wrap_Icon_SetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
5456     PyObject *resultobj;
5457     wxIcon *arg1 = (wxIcon *) 0 ;
5458     long arg2 ;
5459     PyObject * obj0 = 0 ;
5460     PyObject * obj1 = 0 ;
5461     char *kwnames[] = {
5462         (char *) "self",(char *) "handle", NULL
5463     };
5464
5465     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHandle",kwnames,&obj0,&obj1)) goto fail;
5466     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5467     if (SWIG_arg_fail(1)) SWIG_fail;
5468     {
5469         arg2 = (long)(SWIG_As_long(obj1));
5470         if (SWIG_arg_fail(2)) SWIG_fail;
5471     }
5472     {
5473         PyThreadState* __tstate = wxPyBeginAllowThreads();
5474         wxIcon_SetHandle(arg1,arg2);
5475
5476         wxPyEndAllowThreads(__tstate);
5477         if (PyErr_Occurred()) SWIG_fail;
5478     }
5479     Py_INCREF(Py_None); resultobj = Py_None;
5480     return resultobj;
5481     fail:
5482     return NULL;
5483 }
5484
5485
5486 static PyObject *_wrap_Icon_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
5487     PyObject *resultobj;
5488     wxIcon *arg1 = (wxIcon *) 0 ;
5489     bool result;
5490     PyObject * obj0 = 0 ;
5491     char *kwnames[] = {
5492         (char *) "self", NULL
5493     };
5494
5495     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_Ok",kwnames,&obj0)) goto fail;
5496     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5497     if (SWIG_arg_fail(1)) SWIG_fail;
5498     {
5499         PyThreadState* __tstate = wxPyBeginAllowThreads();
5500         result = (bool)(arg1)->Ok();
5501
5502         wxPyEndAllowThreads(__tstate);
5503         if (PyErr_Occurred()) SWIG_fail;
5504     }
5505     {
5506         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5507     }
5508     return resultobj;
5509     fail:
5510     return NULL;
5511 }
5512
5513
5514 static PyObject *_wrap_Icon_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5515     PyObject *resultobj;
5516     wxIcon *arg1 = (wxIcon *) 0 ;
5517     int result;
5518     PyObject * obj0 = 0 ;
5519     char *kwnames[] = {
5520         (char *) "self", NULL
5521     };
5522
5523     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetWidth",kwnames,&obj0)) goto fail;
5524     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5525     if (SWIG_arg_fail(1)) SWIG_fail;
5526     {
5527         PyThreadState* __tstate = wxPyBeginAllowThreads();
5528         result = (int)(arg1)->GetWidth();
5529
5530         wxPyEndAllowThreads(__tstate);
5531         if (PyErr_Occurred()) SWIG_fail;
5532     }
5533     {
5534         resultobj = SWIG_From_int((int)(result));
5535     }
5536     return resultobj;
5537     fail:
5538     return NULL;
5539 }
5540
5541
5542 static PyObject *_wrap_Icon_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5543     PyObject *resultobj;
5544     wxIcon *arg1 = (wxIcon *) 0 ;
5545     int result;
5546     PyObject * obj0 = 0 ;
5547     char *kwnames[] = {
5548         (char *) "self", NULL
5549     };
5550
5551     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetHeight",kwnames,&obj0)) goto fail;
5552     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5553     if (SWIG_arg_fail(1)) SWIG_fail;
5554     {
5555         PyThreadState* __tstate = wxPyBeginAllowThreads();
5556         result = (int)(arg1)->GetHeight();
5557
5558         wxPyEndAllowThreads(__tstate);
5559         if (PyErr_Occurred()) SWIG_fail;
5560     }
5561     {
5562         resultobj = SWIG_From_int((int)(result));
5563     }
5564     return resultobj;
5565     fail:
5566     return NULL;
5567 }
5568
5569
5570 static PyObject *_wrap_Icon_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5571     PyObject *resultobj;
5572     wxIcon *arg1 = (wxIcon *) 0 ;
5573     int result;
5574     PyObject * obj0 = 0 ;
5575     char *kwnames[] = {
5576         (char *) "self", NULL
5577     };
5578
5579     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetDepth",kwnames,&obj0)) goto fail;
5580     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5581     if (SWIG_arg_fail(1)) SWIG_fail;
5582     {
5583         PyThreadState* __tstate = wxPyBeginAllowThreads();
5584         result = (int)(arg1)->GetDepth();
5585
5586         wxPyEndAllowThreads(__tstate);
5587         if (PyErr_Occurred()) SWIG_fail;
5588     }
5589     {
5590         resultobj = SWIG_From_int((int)(result));
5591     }
5592     return resultobj;
5593     fail:
5594     return NULL;
5595 }
5596
5597
5598 static PyObject *_wrap_Icon_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5599     PyObject *resultobj;
5600     wxIcon *arg1 = (wxIcon *) 0 ;
5601     int arg2 ;
5602     PyObject * obj0 = 0 ;
5603     PyObject * obj1 = 0 ;
5604     char *kwnames[] = {
5605         (char *) "self",(char *) "w", NULL
5606     };
5607
5608     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5609     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5610     if (SWIG_arg_fail(1)) SWIG_fail;
5611     {
5612         arg2 = (int)(SWIG_As_int(obj1));
5613         if (SWIG_arg_fail(2)) SWIG_fail;
5614     }
5615     {
5616         PyThreadState* __tstate = wxPyBeginAllowThreads();
5617         (arg1)->SetWidth(arg2);
5618
5619         wxPyEndAllowThreads(__tstate);
5620         if (PyErr_Occurred()) SWIG_fail;
5621     }
5622     Py_INCREF(Py_None); resultobj = Py_None;
5623     return resultobj;
5624     fail:
5625     return NULL;
5626 }
5627
5628
5629 static PyObject *_wrap_Icon_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5630     PyObject *resultobj;
5631     wxIcon *arg1 = (wxIcon *) 0 ;
5632     int arg2 ;
5633     PyObject * obj0 = 0 ;
5634     PyObject * obj1 = 0 ;
5635     char *kwnames[] = {
5636         (char *) "self",(char *) "h", NULL
5637     };
5638
5639     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5640     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5641     if (SWIG_arg_fail(1)) SWIG_fail;
5642     {
5643         arg2 = (int)(SWIG_As_int(obj1));
5644         if (SWIG_arg_fail(2)) SWIG_fail;
5645     }
5646     {
5647         PyThreadState* __tstate = wxPyBeginAllowThreads();
5648         (arg1)->SetHeight(arg2);
5649
5650         wxPyEndAllowThreads(__tstate);
5651         if (PyErr_Occurred()) SWIG_fail;
5652     }
5653     Py_INCREF(Py_None); resultobj = Py_None;
5654     return resultobj;
5655     fail:
5656     return NULL;
5657 }
5658
5659
5660 static PyObject *_wrap_Icon_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5661     PyObject *resultobj;
5662     wxIcon *arg1 = (wxIcon *) 0 ;
5663     int arg2 ;
5664     PyObject * obj0 = 0 ;
5665     PyObject * obj1 = 0 ;
5666     char *kwnames[] = {
5667         (char *) "self",(char *) "d", NULL
5668     };
5669
5670     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetDepth",kwnames,&obj0,&obj1)) goto fail;
5671     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5672     if (SWIG_arg_fail(1)) SWIG_fail;
5673     {
5674         arg2 = (int)(SWIG_As_int(obj1));
5675         if (SWIG_arg_fail(2)) SWIG_fail;
5676     }
5677     {
5678         PyThreadState* __tstate = wxPyBeginAllowThreads();
5679         (arg1)->SetDepth(arg2);
5680
5681         wxPyEndAllowThreads(__tstate);
5682         if (PyErr_Occurred()) SWIG_fail;
5683     }
5684     Py_INCREF(Py_None); resultobj = Py_None;
5685     return resultobj;
5686     fail:
5687     return NULL;
5688 }
5689
5690
5691 static PyObject *_wrap_Icon_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5692     PyObject *resultobj;
5693     wxIcon *arg1 = (wxIcon *) 0 ;
5694     wxSize *arg2 = 0 ;
5695     wxSize temp2 ;
5696     PyObject * obj0 = 0 ;
5697     PyObject * obj1 = 0 ;
5698     char *kwnames[] = {
5699         (char *) "self",(char *) "size", NULL
5700     };
5701
5702     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetSize",kwnames,&obj0,&obj1)) goto fail;
5703     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5704     if (SWIG_arg_fail(1)) SWIG_fail;
5705     {
5706         arg2 = &temp2;
5707         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5708     }
5709     {
5710         PyThreadState* __tstate = wxPyBeginAllowThreads();
5711         (arg1)->SetSize((wxSize const &)*arg2);
5712
5713         wxPyEndAllowThreads(__tstate);
5714         if (PyErr_Occurred()) SWIG_fail;
5715     }
5716     Py_INCREF(Py_None); resultobj = Py_None;
5717     return resultobj;
5718     fail:
5719     return NULL;
5720 }
5721
5722
5723 static PyObject *_wrap_Icon_CopyFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5724     PyObject *resultobj;
5725     wxIcon *arg1 = (wxIcon *) 0 ;
5726     wxBitmap *arg2 = 0 ;
5727     PyObject * obj0 = 0 ;
5728     PyObject * obj1 = 0 ;
5729     char *kwnames[] = {
5730         (char *) "self",(char *) "bmp", NULL
5731     };
5732
5733     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_CopyFromBitmap",kwnames,&obj0,&obj1)) goto fail;
5734     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5735     if (SWIG_arg_fail(1)) SWIG_fail;
5736     {
5737         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5738         if (SWIG_arg_fail(2)) SWIG_fail;
5739         if (arg2 == NULL) {
5740             SWIG_null_ref("wxBitmap");
5741         }
5742         if (SWIG_arg_fail(2)) SWIG_fail;
5743     }
5744     {
5745         PyThreadState* __tstate = wxPyBeginAllowThreads();
5746         (arg1)->CopyFromBitmap((wxBitmap const &)*arg2);
5747
5748         wxPyEndAllowThreads(__tstate);
5749         if (PyErr_Occurred()) SWIG_fail;
5750     }
5751     Py_INCREF(Py_None); resultobj = Py_None;
5752     return resultobj;
5753     fail:
5754     return NULL;
5755 }
5756
5757
5758 static PyObject * Icon_swigregister(PyObject *, PyObject *args) {
5759     PyObject *obj;
5760     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5761     SWIG_TypeClientData(SWIGTYPE_p_wxIcon, obj);
5762     Py_INCREF(obj);
5763     return Py_BuildValue((char *)"");
5764 }
5765 static PyObject *_wrap_new_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5766     PyObject *resultobj;
5767     wxString *arg1 = (wxString *) &wxPyEmptyString ;
5768     int arg2 = (int) 0 ;
5769     wxIconLocation *result;
5770     bool temp1 = false ;
5771     PyObject * obj0 = 0 ;
5772     PyObject * obj1 = 0 ;
5773     char *kwnames[] = {
5774         (char *) "filename",(char *) "num", NULL
5775     };
5776
5777     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconLocation",kwnames,&obj0,&obj1)) goto fail;
5778     if (obj0) {
5779         {
5780             arg1 = wxString_in_helper(obj0);
5781             if (arg1 == NULL) SWIG_fail;
5782             temp1 = true;
5783         }
5784     }
5785     if (obj1) {
5786         {
5787             arg2 = (int)(SWIG_As_int(obj1));
5788             if (SWIG_arg_fail(2)) SWIG_fail;
5789         }
5790     }
5791     {
5792         PyThreadState* __tstate = wxPyBeginAllowThreads();
5793         result = (wxIconLocation *)new_wxIconLocation((wxString const *)arg1,arg2);
5794
5795         wxPyEndAllowThreads(__tstate);
5796         if (PyErr_Occurred()) SWIG_fail;
5797     }
5798     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconLocation, 1);
5799     {
5800         if (temp1)
5801         delete arg1;
5802     }
5803     return resultobj;
5804     fail:
5805     {
5806         if (temp1)
5807         delete arg1;
5808     }
5809     return NULL;
5810 }
5811
5812
5813 static PyObject *_wrap_delete_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5814     PyObject *resultobj;
5815     wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5816     PyObject * obj0 = 0 ;
5817     char *kwnames[] = {
5818         (char *) "self", NULL
5819     };
5820
5821     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconLocation",kwnames,&obj0)) goto fail;
5822     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5823     if (SWIG_arg_fail(1)) SWIG_fail;
5824     {
5825         PyThreadState* __tstate = wxPyBeginAllowThreads();
5826         delete arg1;
5827
5828         wxPyEndAllowThreads(__tstate);
5829         if (PyErr_Occurred()) SWIG_fail;
5830     }
5831     Py_INCREF(Py_None); resultobj = Py_None;
5832     return resultobj;
5833     fail:
5834     return NULL;
5835 }
5836
5837
5838 static PyObject *_wrap_IconLocation_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
5839     PyObject *resultobj;
5840     wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5841     bool result;
5842     PyObject * obj0 = 0 ;
5843     char *kwnames[] = {
5844         (char *) "self", NULL
5845     };
5846
5847     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_IsOk",kwnames,&obj0)) goto fail;
5848     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5849     if (SWIG_arg_fail(1)) SWIG_fail;
5850     {
5851         PyThreadState* __tstate = wxPyBeginAllowThreads();
5852         result = (bool)((wxIconLocation const *)arg1)->IsOk();
5853
5854         wxPyEndAllowThreads(__tstate);
5855         if (PyErr_Occurred()) SWIG_fail;
5856     }
5857     {
5858         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5859     }
5860     return resultobj;
5861     fail:
5862     return NULL;
5863 }
5864
5865
5866 static PyObject *_wrap_IconLocation_SetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5867     PyObject *resultobj;
5868     wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5869     wxString *arg2 = 0 ;
5870     bool temp2 = false ;
5871     PyObject * obj0 = 0 ;
5872     PyObject * obj1 = 0 ;
5873     char *kwnames[] = {
5874         (char *) "self",(char *) "filename", NULL
5875     };
5876
5877     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetFileName",kwnames,&obj0,&obj1)) goto fail;
5878     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5879     if (SWIG_arg_fail(1)) SWIG_fail;
5880     {
5881         arg2 = wxString_in_helper(obj1);
5882         if (arg2 == NULL) SWIG_fail;
5883         temp2 = true;
5884     }
5885     {
5886         PyThreadState* __tstate = wxPyBeginAllowThreads();
5887         (arg1)->SetFileName((wxString const &)*arg2);
5888
5889         wxPyEndAllowThreads(__tstate);
5890         if (PyErr_Occurred()) SWIG_fail;
5891     }
5892     Py_INCREF(Py_None); resultobj = Py_None;
5893     {
5894         if (temp2)
5895         delete arg2;
5896     }
5897     return resultobj;
5898     fail:
5899     {
5900         if (temp2)
5901         delete arg2;
5902     }
5903     return NULL;
5904 }
5905
5906
5907 static PyObject *_wrap_IconLocation_GetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5908     PyObject *resultobj;
5909     wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5910     wxString *result;
5911     PyObject * obj0 = 0 ;
5912     char *kwnames[] = {
5913         (char *) "self", NULL
5914     };
5915
5916     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetFileName",kwnames,&obj0)) goto fail;
5917     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5918     if (SWIG_arg_fail(1)) SWIG_fail;
5919     {
5920         PyThreadState* __tstate = wxPyBeginAllowThreads();
5921         {
5922             wxString const &_result_ref = ((wxIconLocation const *)arg1)->GetFileName();
5923             result = (wxString *) &_result_ref;
5924         }
5925
5926         wxPyEndAllowThreads(__tstate);
5927         if (PyErr_Occurred()) SWIG_fail;
5928     }
5929     {
5930 #if wxUSE_UNICODE
5931         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
5932 #else
5933         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
5934 #endif
5935     }
5936     return resultobj;
5937     fail:
5938     return NULL;
5939 }
5940
5941
5942 static PyObject *_wrap_IconLocation_SetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5943     PyObject *resultobj;
5944     wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5945     int arg2 ;
5946     PyObject * obj0 = 0 ;
5947     PyObject * obj1 = 0 ;
5948     char *kwnames[] = {
5949         (char *) "self",(char *) "num", NULL
5950     };
5951
5952     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetIndex",kwnames,&obj0,&obj1)) goto fail;
5953     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5954     if (SWIG_arg_fail(1)) SWIG_fail;
5955     {
5956         arg2 = (int)(SWIG_As_int(obj1));
5957         if (SWIG_arg_fail(2)) SWIG_fail;
5958     }
5959     {
5960         PyThreadState* __tstate = wxPyBeginAllowThreads();
5961         wxIconLocation_SetIndex(arg1,arg2);
5962
5963         wxPyEndAllowThreads(__tstate);
5964         if (PyErr_Occurred()) SWIG_fail;
5965     }
5966     Py_INCREF(Py_None); resultobj = Py_None;
5967     return resultobj;
5968     fail:
5969     return NULL;
5970 }
5971
5972
5973 static PyObject *_wrap_IconLocation_GetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5974     PyObject *resultobj;
5975     wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5976     int result;
5977     PyObject * obj0 = 0 ;
5978     char *kwnames[] = {
5979         (char *) "self", NULL
5980     };
5981
5982     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetIndex",kwnames,&obj0)) goto fail;
5983     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5984     if (SWIG_arg_fail(1)) SWIG_fail;
5985     {
5986         PyThreadState* __tstate = wxPyBeginAllowThreads();
5987         result = (int)wxIconLocation_GetIndex(arg1);
5988
5989         wxPyEndAllowThreads(__tstate);
5990         if (PyErr_Occurred()) SWIG_fail;
5991     }
5992     {
5993         resultobj = SWIG_From_int((int)(result));
5994     }
5995     return resultobj;
5996     fail:
5997     return NULL;
5998 }
5999
6000
6001 static PyObject * IconLocation_swigregister(PyObject *, PyObject *args) {
6002     PyObject *obj;
6003     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6004     SWIG_TypeClientData(SWIGTYPE_p_wxIconLocation, obj);
6005     Py_INCREF(obj);
6006     return Py_BuildValue((char *)"");
6007 }
6008 static PyObject *_wrap_new_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
6009     PyObject *resultobj;
6010     wxIconBundle *result;
6011     char *kwnames[] = {
6012         NULL
6013     };
6014
6015     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IconBundle",kwnames)) goto fail;
6016     {
6017         PyThreadState* __tstate = wxPyBeginAllowThreads();
6018         result = (wxIconBundle *)new wxIconBundle();
6019
6020         wxPyEndAllowThreads(__tstate);
6021         if (PyErr_Occurred()) SWIG_fail;
6022     }
6023     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
6024     return resultobj;
6025     fail:
6026     return NULL;
6027 }
6028
6029
6030 static PyObject *_wrap_new_IconBundleFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
6031     PyObject *resultobj;
6032     wxString *arg1 = 0 ;
6033     long arg2 ;
6034     wxIconBundle *result;
6035     bool temp1 = false ;
6036     PyObject * obj0 = 0 ;
6037     PyObject * obj1 = 0 ;
6038     char *kwnames[] = {
6039         (char *) "file",(char *) "type", NULL
6040     };
6041
6042     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_IconBundleFromFile",kwnames,&obj0,&obj1)) goto fail;
6043     {
6044         arg1 = wxString_in_helper(obj0);
6045         if (arg1 == NULL) SWIG_fail;
6046         temp1 = true;
6047     }
6048     {
6049         arg2 = (long)(SWIG_As_long(obj1));
6050         if (SWIG_arg_fail(2)) SWIG_fail;
6051     }
6052     {
6053         PyThreadState* __tstate = wxPyBeginAllowThreads();
6054         result = (wxIconBundle *)new wxIconBundle((wxString const &)*arg1,arg2);
6055
6056         wxPyEndAllowThreads(__tstate);
6057         if (PyErr_Occurred()) SWIG_fail;
6058     }
6059     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
6060     {
6061         if (temp1)
6062         delete arg1;
6063     }
6064     return resultobj;
6065     fail:
6066     {
6067         if (temp1)
6068         delete arg1;
6069     }
6070     return NULL;
6071 }
6072
6073
6074 static PyObject *_wrap_new_IconBundleFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
6075     PyObject *resultobj;
6076     wxIcon *arg1 = 0 ;
6077     wxIconBundle *result;
6078     PyObject * obj0 = 0 ;
6079     char *kwnames[] = {
6080         (char *) "icon", NULL
6081     };
6082
6083     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconBundleFromIcon",kwnames,&obj0)) goto fail;
6084     {
6085         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
6086         if (SWIG_arg_fail(1)) SWIG_fail;
6087         if (arg1 == NULL) {
6088             SWIG_null_ref("wxIcon");
6089         }
6090         if (SWIG_arg_fail(1)) SWIG_fail;
6091     }
6092     {
6093         PyThreadState* __tstate = wxPyBeginAllowThreads();
6094         result = (wxIconBundle *)new wxIconBundle((wxIcon const &)*arg1);
6095
6096         wxPyEndAllowThreads(__tstate);
6097         if (PyErr_Occurred()) SWIG_fail;
6098     }
6099     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
6100     return resultobj;
6101     fail:
6102     return NULL;
6103 }
6104
6105
6106 static PyObject *_wrap_delete_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
6107     PyObject *resultobj;
6108     wxIconBundle *arg1 = (wxIconBundle *) 0 ;
6109     PyObject * obj0 = 0 ;
6110     char *kwnames[] = {
6111         (char *) "self", NULL
6112     };
6113
6114     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconBundle",kwnames,&obj0)) goto fail;
6115     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
6116     if (SWIG_arg_fail(1)) SWIG_fail;
6117     {
6118         PyThreadState* __tstate = wxPyBeginAllowThreads();
6119         delete arg1;
6120
6121         wxPyEndAllowThreads(__tstate);
6122         if (PyErr_Occurred()) SWIG_fail;
6123     }
6124     Py_INCREF(Py_None); resultobj = Py_None;
6125     return resultobj;
6126     fail:
6127     return NULL;
6128 }
6129
6130
6131 static PyObject *_wrap_IconBundle_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
6132     PyObject *resultobj;
6133     wxIconBundle *arg1 = (wxIconBundle *) 0 ;
6134     wxIcon *arg2 = 0 ;
6135     PyObject * obj0 = 0 ;
6136     PyObject * obj1 = 0 ;
6137     char *kwnames[] = {
6138         (char *) "self",(char *) "icon", NULL
6139     };
6140
6141     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_AddIcon",kwnames,&obj0,&obj1)) goto fail;
6142     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
6143     if (SWIG_arg_fail(1)) SWIG_fail;
6144     {
6145         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
6146         if (SWIG_arg_fail(2)) SWIG_fail;
6147         if (arg2 == NULL) {
6148             SWIG_null_ref("wxIcon");
6149         }
6150         if (SWIG_arg_fail(2)) SWIG_fail;
6151     }
6152     {
6153         PyThreadState* __tstate = wxPyBeginAllowThreads();
6154         (arg1)->AddIcon((wxIcon const &)*arg2);
6155
6156         wxPyEndAllowThreads(__tstate);
6157         if (PyErr_Occurred()) SWIG_fail;
6158     }
6159     Py_INCREF(Py_None); resultobj = Py_None;
6160     return resultobj;
6161     fail:
6162     return NULL;
6163 }
6164
6165
6166 static PyObject *_wrap_IconBundle_AddIconFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
6167     PyObject *resultobj;
6168     wxIconBundle *arg1 = (wxIconBundle *) 0 ;
6169     wxString *arg2 = 0 ;
6170     long arg3 ;
6171     bool temp2 = false ;
6172     PyObject * obj0 = 0 ;
6173     PyObject * obj1 = 0 ;
6174     PyObject * obj2 = 0 ;
6175     char *kwnames[] = {
6176         (char *) "self",(char *) "file",(char *) "type", NULL
6177     };
6178
6179     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IconBundle_AddIconFromFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
6180     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
6181     if (SWIG_arg_fail(1)) SWIG_fail;
6182     {
6183         arg2 = wxString_in_helper(obj1);
6184         if (arg2 == NULL) SWIG_fail;
6185         temp2 = true;
6186     }
6187     {
6188         arg3 = (long)(SWIG_As_long(obj2));
6189         if (SWIG_arg_fail(3)) SWIG_fail;
6190     }
6191     {
6192         PyThreadState* __tstate = wxPyBeginAllowThreads();
6193         (arg1)->AddIcon((wxString const &)*arg2,arg3);
6194
6195         wxPyEndAllowThreads(__tstate);
6196         if (PyErr_Occurred()) SWIG_fail;
6197     }
6198     Py_INCREF(Py_None); resultobj = Py_None;
6199     {
6200         if (temp2)
6201         delete arg2;
6202     }
6203     return resultobj;
6204     fail:
6205     {
6206         if (temp2)
6207         delete arg2;
6208     }
6209     return NULL;
6210 }
6211
6212
6213 static PyObject *_wrap_IconBundle_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
6214     PyObject *resultobj;
6215     wxIconBundle *arg1 = (wxIconBundle *) 0 ;
6216     wxSize *arg2 = 0 ;
6217     wxIcon *result;
6218     wxSize temp2 ;
6219     PyObject * obj0 = 0 ;
6220     PyObject * obj1 = 0 ;
6221     char *kwnames[] = {
6222         (char *) "self",(char *) "size", NULL
6223     };
6224
6225     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_GetIcon",kwnames,&obj0,&obj1)) goto fail;
6226     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
6227     if (SWIG_arg_fail(1)) SWIG_fail;
6228     {
6229         arg2 = &temp2;
6230         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6231     }
6232     {
6233         PyThreadState* __tstate = wxPyBeginAllowThreads();
6234         {
6235             wxIcon const &_result_ref = ((wxIconBundle const *)arg1)->GetIcon((wxSize const &)*arg2);
6236             result = (wxIcon *) &_result_ref;
6237         }
6238
6239         wxPyEndAllowThreads(__tstate);
6240         if (PyErr_Occurred()) SWIG_fail;
6241     }
6242     {
6243         wxIcon* resultptr = new wxIcon(*result);
6244         resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxIcon, 1);
6245     }
6246     return resultobj;
6247     fail:
6248     return NULL;
6249 }
6250
6251
6252 static PyObject * IconBundle_swigregister(PyObject *, PyObject *args) {
6253     PyObject *obj;
6254     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6255     SWIG_TypeClientData(SWIGTYPE_p_wxIconBundle, obj);
6256     Py_INCREF(obj);
6257     return Py_BuildValue((char *)"");
6258 }
6259 static PyObject *_wrap_new_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
6260     PyObject *resultobj;
6261     wxString *arg1 = 0 ;
6262     long arg2 ;
6263     int arg3 = (int) 0 ;
6264     int arg4 = (int) 0 ;
6265     wxCursor *result;
6266     bool temp1 = false ;
6267     PyObject * obj0 = 0 ;
6268     PyObject * obj1 = 0 ;
6269     PyObject * obj2 = 0 ;
6270     PyObject * obj3 = 0 ;
6271     char *kwnames[] = {
6272         (char *) "cursorName",(char *) "type",(char *) "hotSpotX",(char *) "hotSpotY", NULL
6273     };
6274
6275     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Cursor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6276     {
6277         arg1 = wxString_in_helper(obj0);
6278         if (arg1 == NULL) SWIG_fail;
6279         temp1 = true;
6280     }
6281     {
6282         arg2 = (long)(SWIG_As_long(obj1));
6283         if (SWIG_arg_fail(2)) SWIG_fail;
6284     }
6285     if (obj2) {
6286         {
6287             arg3 = (int)(SWIG_As_int(obj2));
6288             if (SWIG_arg_fail(3)) SWIG_fail;
6289         }
6290     }
6291     if (obj3) {
6292         {
6293             arg4 = (int)(SWIG_As_int(obj3));
6294             if (SWIG_arg_fail(4)) SWIG_fail;
6295         }
6296     }
6297     {
6298         if (!wxPyCheckForApp()) SWIG_fail;
6299         PyThreadState* __tstate = wxPyBeginAllowThreads();
6300         result = (wxCursor *)new_wxCursor((wxString const &)*arg1,arg2,arg3,arg4);
6301
6302         wxPyEndAllowThreads(__tstate);
6303         if (PyErr_Occurred()) SWIG_fail;
6304     }
6305     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6306     {
6307         if (temp1)
6308         delete arg1;
6309     }
6310     return resultobj;
6311     fail:
6312     {
6313         if (temp1)
6314         delete arg1;
6315     }
6316     return NULL;
6317 }
6318
6319
6320 static PyObject *_wrap_delete_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
6321     PyObject *resultobj;
6322     wxCursor *arg1 = (wxCursor *) 0 ;
6323     PyObject * obj0 = 0 ;
6324     char *kwnames[] = {
6325         (char *) "self", NULL
6326     };
6327
6328     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Cursor",kwnames,&obj0)) goto fail;
6329     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6330     if (SWIG_arg_fail(1)) SWIG_fail;
6331     {
6332         PyThreadState* __tstate = wxPyBeginAllowThreads();
6333         delete arg1;
6334
6335         wxPyEndAllowThreads(__tstate);
6336         if (PyErr_Occurred()) SWIG_fail;
6337     }
6338     Py_INCREF(Py_None); resultobj = Py_None;
6339     return resultobj;
6340     fail:
6341     return NULL;
6342 }
6343
6344
6345 static PyObject *_wrap_new_StockCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6346     PyObject *resultobj;
6347     int arg1 ;
6348     wxCursor *result;
6349     PyObject * obj0 = 0 ;
6350     char *kwnames[] = {
6351         (char *) "id", NULL
6352     };
6353
6354     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_StockCursor",kwnames,&obj0)) goto fail;
6355     {
6356         arg1 = (int)(SWIG_As_int(obj0));
6357         if (SWIG_arg_fail(1)) SWIG_fail;
6358     }
6359     {
6360         if (!wxPyCheckForApp()) SWIG_fail;
6361         PyThreadState* __tstate = wxPyBeginAllowThreads();
6362         result = (wxCursor *)new wxCursor(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_new_CursorFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
6375     PyObject *resultobj;
6376     wxImage *arg1 = 0 ;
6377     wxCursor *result;
6378     PyObject * obj0 = 0 ;
6379     char *kwnames[] = {
6380         (char *) "image", NULL
6381     };
6382
6383     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CursorFromImage",kwnames,&obj0)) goto fail;
6384     {
6385         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
6386         if (SWIG_arg_fail(1)) SWIG_fail;
6387         if (arg1 == NULL) {
6388             SWIG_null_ref("wxImage");
6389         }
6390         if (SWIG_arg_fail(1)) SWIG_fail;
6391     }
6392     {
6393         if (!wxPyCheckForApp()) SWIG_fail;
6394         PyThreadState* __tstate = wxPyBeginAllowThreads();
6395         result = (wxCursor *)new wxCursor((wxImage const &)*arg1);
6396
6397         wxPyEndAllowThreads(__tstate);
6398         if (PyErr_Occurred()) SWIG_fail;
6399     }
6400     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6401     return resultobj;
6402     fail:
6403     return NULL;
6404 }
6405
6406
6407 static PyObject *_wrap_Cursor_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
6408     PyObject *resultobj;
6409     wxCursor *arg1 = (wxCursor *) 0 ;
6410     long result;
6411     PyObject * obj0 = 0 ;
6412     char *kwnames[] = {
6413         (char *) "self", NULL
6414     };
6415
6416     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_GetHandle",kwnames,&obj0)) goto fail;
6417     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6418     if (SWIG_arg_fail(1)) SWIG_fail;
6419     {
6420         PyThreadState* __tstate = wxPyBeginAllowThreads();
6421         result = (long)(arg1)->GetHandle();
6422
6423         wxPyEndAllowThreads(__tstate);
6424         if (PyErr_Occurred()) SWIG_fail;
6425     }
6426     {
6427         resultobj = SWIG_From_long((long)(result));
6428     }
6429     return resultobj;
6430     fail:
6431     return NULL;
6432 }
6433
6434
6435 static PyObject *_wrap_Cursor_SetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
6436     PyObject *resultobj;
6437     wxCursor *arg1 = (wxCursor *) 0 ;
6438     long arg2 ;
6439     PyObject * obj0 = 0 ;
6440     PyObject * obj1 = 0 ;
6441     char *kwnames[] = {
6442         (char *) "self",(char *) "handle", NULL
6443     };
6444
6445     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetHandle",kwnames,&obj0,&obj1)) goto fail;
6446     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6447     if (SWIG_arg_fail(1)) SWIG_fail;
6448     {
6449         arg2 = (long)(SWIG_As_long(obj1));
6450         if (SWIG_arg_fail(2)) SWIG_fail;
6451     }
6452     {
6453         PyThreadState* __tstate = wxPyBeginAllowThreads();
6454         wxCursor_SetHandle(arg1,arg2);
6455
6456         wxPyEndAllowThreads(__tstate);
6457         if (PyErr_Occurred()) SWIG_fail;
6458     }
6459     Py_INCREF(Py_None); resultobj = Py_None;
6460     return resultobj;
6461     fail:
6462     return NULL;
6463 }
6464
6465
6466 static PyObject *_wrap_Cursor_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
6467     PyObject *resultobj;
6468     wxCursor *arg1 = (wxCursor *) 0 ;
6469     bool result;
6470     PyObject * obj0 = 0 ;
6471     char *kwnames[] = {
6472         (char *) "self", NULL
6473     };
6474
6475     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_Ok",kwnames,&obj0)) goto fail;
6476     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6477     if (SWIG_arg_fail(1)) SWIG_fail;
6478     {
6479         PyThreadState* __tstate = wxPyBeginAllowThreads();
6480         result = (bool)(arg1)->Ok();
6481
6482         wxPyEndAllowThreads(__tstate);
6483         if (PyErr_Occurred()) SWIG_fail;
6484     }
6485     {
6486         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6487     }
6488     return resultobj;
6489     fail:
6490     return NULL;
6491 }
6492
6493
6494 static PyObject *_wrap_Cursor_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
6495     PyObject *resultobj;
6496     wxCursor *arg1 = (wxCursor *) 0 ;
6497     int result;
6498     PyObject * obj0 = 0 ;
6499     char *kwnames[] = {
6500         (char *) "self", NULL
6501     };
6502
6503     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_GetWidth",kwnames,&obj0)) goto fail;
6504     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6505     if (SWIG_arg_fail(1)) SWIG_fail;
6506     {
6507         PyThreadState* __tstate = wxPyBeginAllowThreads();
6508         result = (int)(arg1)->GetWidth();
6509
6510         wxPyEndAllowThreads(__tstate);
6511         if (PyErr_Occurred()) SWIG_fail;
6512     }
6513     {
6514         resultobj = SWIG_From_int((int)(result));
6515     }
6516     return resultobj;
6517     fail:
6518     return NULL;
6519 }
6520
6521
6522 static PyObject *_wrap_Cursor_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
6523     PyObject *resultobj;
6524     wxCursor *arg1 = (wxCursor *) 0 ;
6525     int result;
6526     PyObject * obj0 = 0 ;
6527     char *kwnames[] = {
6528         (char *) "self", NULL
6529     };
6530
6531     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_GetHeight",kwnames,&obj0)) goto fail;
6532     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6533     if (SWIG_arg_fail(1)) SWIG_fail;
6534     {
6535         PyThreadState* __tstate = wxPyBeginAllowThreads();
6536         result = (int)(arg1)->GetHeight();
6537
6538         wxPyEndAllowThreads(__tstate);
6539         if (PyErr_Occurred()) SWIG_fail;
6540     }
6541     {
6542         resultobj = SWIG_From_int((int)(result));
6543     }
6544     return resultobj;
6545     fail:
6546     return NULL;
6547 }
6548
6549
6550 static PyObject *_wrap_Cursor_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
6551     PyObject *resultobj;
6552     wxCursor *arg1 = (wxCursor *) 0 ;
6553     int result;
6554     PyObject * obj0 = 0 ;
6555     char *kwnames[] = {
6556         (char *) "self", NULL
6557     };
6558
6559     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_GetDepth",kwnames,&obj0)) goto fail;
6560     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6561     if (SWIG_arg_fail(1)) SWIG_fail;
6562     {
6563         PyThreadState* __tstate = wxPyBeginAllowThreads();
6564         result = (int)(arg1)->GetDepth();
6565
6566         wxPyEndAllowThreads(__tstate);
6567         if (PyErr_Occurred()) SWIG_fail;
6568     }
6569     {
6570         resultobj = SWIG_From_int((int)(result));
6571     }
6572     return resultobj;
6573     fail:
6574     return NULL;
6575 }
6576
6577
6578 static PyObject *_wrap_Cursor_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
6579     PyObject *resultobj;
6580     wxCursor *arg1 = (wxCursor *) 0 ;
6581     int arg2 ;
6582     PyObject * obj0 = 0 ;
6583     PyObject * obj1 = 0 ;
6584     char *kwnames[] = {
6585         (char *) "self",(char *) "w", NULL
6586     };
6587
6588     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetWidth",kwnames,&obj0,&obj1)) goto fail;
6589     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6590     if (SWIG_arg_fail(1)) SWIG_fail;
6591     {
6592         arg2 = (int)(SWIG_As_int(obj1));
6593         if (SWIG_arg_fail(2)) SWIG_fail;
6594     }
6595     {
6596         PyThreadState* __tstate = wxPyBeginAllowThreads();
6597         (arg1)->SetWidth(arg2);
6598
6599         wxPyEndAllowThreads(__tstate);
6600         if (PyErr_Occurred()) SWIG_fail;
6601     }
6602     Py_INCREF(Py_None); resultobj = Py_None;
6603     return resultobj;
6604     fail:
6605     return NULL;
6606 }
6607
6608
6609 static PyObject *_wrap_Cursor_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
6610     PyObject *resultobj;
6611     wxCursor *arg1 = (wxCursor *) 0 ;
6612     int arg2 ;
6613     PyObject * obj0 = 0 ;
6614     PyObject * obj1 = 0 ;
6615     char *kwnames[] = {
6616         (char *) "self",(char *) "h", NULL
6617     };
6618
6619     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetHeight",kwnames,&obj0,&obj1)) goto fail;
6620     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6621     if (SWIG_arg_fail(1)) SWIG_fail;
6622     {
6623         arg2 = (int)(SWIG_As_int(obj1));
6624         if (SWIG_arg_fail(2)) SWIG_fail;
6625     }
6626     {
6627         PyThreadState* __tstate = wxPyBeginAllowThreads();
6628         (arg1)->SetHeight(arg2);
6629
6630         wxPyEndAllowThreads(__tstate);
6631         if (PyErr_Occurred()) SWIG_fail;
6632     }
6633     Py_INCREF(Py_None); resultobj = Py_None;
6634     return resultobj;
6635     fail:
6636     return NULL;
6637 }
6638
6639
6640 static PyObject *_wrap_Cursor_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
6641     PyObject *resultobj;
6642     wxCursor *arg1 = (wxCursor *) 0 ;
6643     int arg2 ;
6644     PyObject * obj0 = 0 ;
6645     PyObject * obj1 = 0 ;
6646     char *kwnames[] = {
6647         (char *) "self",(char *) "d", NULL
6648     };
6649
6650     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetDepth",kwnames,&obj0,&obj1)) goto fail;
6651     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6652     if (SWIG_arg_fail(1)) SWIG_fail;
6653     {
6654         arg2 = (int)(SWIG_As_int(obj1));
6655         if (SWIG_arg_fail(2)) SWIG_fail;
6656     }
6657     {
6658         PyThreadState* __tstate = wxPyBeginAllowThreads();
6659         (arg1)->SetDepth(arg2);
6660
6661         wxPyEndAllowThreads(__tstate);
6662         if (PyErr_Occurred()) SWIG_fail;
6663     }
6664     Py_INCREF(Py_None); resultobj = Py_None;
6665     return resultobj;
6666     fail:
6667     return NULL;
6668 }
6669
6670
6671 static PyObject *_wrap_Cursor_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6672     PyObject *resultobj;
6673     wxCursor *arg1 = (wxCursor *) 0 ;
6674     wxSize *arg2 = 0 ;
6675     wxSize temp2 ;
6676     PyObject * obj0 = 0 ;
6677     PyObject * obj1 = 0 ;
6678     char *kwnames[] = {
6679         (char *) "self",(char *) "size", NULL
6680     };
6681
6682     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetSize",kwnames,&obj0,&obj1)) goto fail;
6683     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6684     if (SWIG_arg_fail(1)) SWIG_fail;
6685     {
6686         arg2 = &temp2;
6687         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6688     }
6689     {
6690         PyThreadState* __tstate = wxPyBeginAllowThreads();
6691         (arg1)->SetSize((wxSize const &)*arg2);
6692
6693         wxPyEndAllowThreads(__tstate);
6694         if (PyErr_Occurred()) SWIG_fail;
6695     }
6696     Py_INCREF(Py_None); resultobj = Py_None;
6697     return resultobj;
6698     fail:
6699     return NULL;
6700 }
6701
6702
6703 static PyObject * Cursor_swigregister(PyObject *, PyObject *args) {
6704     PyObject *obj;
6705     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6706     SWIG_TypeClientData(SWIGTYPE_p_wxCursor, obj);
6707     Py_INCREF(obj);
6708     return Py_BuildValue((char *)"");
6709 }
6710 static PyObject *_wrap_new_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6711     PyObject *resultobj;
6712     int arg1 = (int) 0 ;
6713     int arg2 = (int) 0 ;
6714     int arg3 = (int) 0 ;
6715     int arg4 = (int) 0 ;
6716     wxRegion *result;
6717     PyObject * obj0 = 0 ;
6718     PyObject * obj1 = 0 ;
6719     PyObject * obj2 = 0 ;
6720     PyObject * obj3 = 0 ;
6721     char *kwnames[] = {
6722         (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6723     };
6724
6725     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Region",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6726     if (obj0) {
6727         {
6728             arg1 = (int)(SWIG_As_int(obj0));
6729             if (SWIG_arg_fail(1)) SWIG_fail;
6730         }
6731     }
6732     if (obj1) {
6733         {
6734             arg2 = (int)(SWIG_As_int(obj1));
6735             if (SWIG_arg_fail(2)) SWIG_fail;
6736         }
6737     }
6738     if (obj2) {
6739         {
6740             arg3 = (int)(SWIG_As_int(obj2));
6741             if (SWIG_arg_fail(3)) SWIG_fail;
6742         }
6743     }
6744     if (obj3) {
6745         {
6746             arg4 = (int)(SWIG_As_int(obj3));
6747             if (SWIG_arg_fail(4)) SWIG_fail;
6748         }
6749     }
6750     {
6751         if (!wxPyCheckForApp()) SWIG_fail;
6752         PyThreadState* __tstate = wxPyBeginAllowThreads();
6753         result = (wxRegion *)new wxRegion(arg1,arg2,arg3,arg4);
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_RegionFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6766     PyObject *resultobj;
6767     wxBitmap *arg1 = 0 ;
6768     wxRegion *result;
6769     PyObject * obj0 = 0 ;
6770     char *kwnames[] = {
6771         (char *) "bmp", NULL
6772     };
6773
6774     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionFromBitmap",kwnames,&obj0)) goto fail;
6775     {
6776         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6777         if (SWIG_arg_fail(1)) SWIG_fail;
6778         if (arg1 == NULL) {
6779             SWIG_null_ref("wxBitmap");
6780         }
6781         if (SWIG_arg_fail(1)) SWIG_fail;
6782     }
6783     {
6784         if (!wxPyCheckForApp()) SWIG_fail;
6785         PyThreadState* __tstate = wxPyBeginAllowThreads();
6786         result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1);
6787
6788         wxPyEndAllowThreads(__tstate);
6789         if (PyErr_Occurred()) SWIG_fail;
6790     }
6791     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6792     return resultobj;
6793     fail:
6794     return NULL;
6795 }
6796
6797
6798 static PyObject *_wrap_new_RegionFromBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
6799     PyObject *resultobj;
6800     wxBitmap *arg1 = 0 ;
6801     wxColour *arg2 = 0 ;
6802     int arg3 = (int) 0 ;
6803     wxRegion *result;
6804     wxColour temp2 ;
6805     PyObject * obj0 = 0 ;
6806     PyObject * obj1 = 0 ;
6807     PyObject * obj2 = 0 ;
6808     char *kwnames[] = {
6809         (char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
6810     };
6811
6812     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_RegionFromBitmapColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
6813     {
6814         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6815         if (SWIG_arg_fail(1)) SWIG_fail;
6816         if (arg1 == NULL) {
6817             SWIG_null_ref("wxBitmap");
6818         }
6819         if (SWIG_arg_fail(1)) SWIG_fail;
6820     }
6821     {
6822         arg2 = &temp2;
6823         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6824     }
6825     if (obj2) {
6826         {
6827             arg3 = (int)(SWIG_As_int(obj2));
6828             if (SWIG_arg_fail(3)) SWIG_fail;
6829         }
6830     }
6831     {
6832         if (!wxPyCheckForApp()) SWIG_fail;
6833         PyThreadState* __tstate = wxPyBeginAllowThreads();
6834         result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1,(wxColour const &)*arg2,arg3);
6835
6836         wxPyEndAllowThreads(__tstate);
6837         if (PyErr_Occurred()) SWIG_fail;
6838     }
6839     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6840     return resultobj;
6841     fail:
6842     return NULL;
6843 }
6844
6845
6846 static PyObject *_wrap_new_RegionFromPoints(PyObject *, PyObject *args, PyObject *kwargs) {
6847     PyObject *resultobj;
6848     int arg1 ;
6849     wxPoint *arg2 = (wxPoint *) 0 ;
6850     int arg3 = (int) wxWINDING_RULE ;
6851     wxRegion *result;
6852     PyObject * obj0 = 0 ;
6853     PyObject * obj1 = 0 ;
6854     char *kwnames[] = {
6855         (char *) "points",(char *) "fillStyle", NULL
6856     };
6857
6858     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_RegionFromPoints",kwnames,&obj0,&obj1)) goto fail;
6859     {
6860         arg2 = wxPoint_LIST_helper(obj0, &arg1);
6861         if (arg2 == NULL) SWIG_fail;
6862     }
6863     if (obj1) {
6864         {
6865             arg3 = (int)(SWIG_As_int(obj1));
6866             if (SWIG_arg_fail(3)) SWIG_fail;
6867         }
6868     }
6869     {
6870         if (!wxPyCheckForApp()) SWIG_fail;
6871         PyThreadState* __tstate = wxPyBeginAllowThreads();
6872         result = (wxRegion *)new wxRegion(arg1,arg2,arg3);
6873
6874         wxPyEndAllowThreads(__tstate);
6875         if (PyErr_Occurred()) SWIG_fail;
6876     }
6877     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6878     {
6879         if (arg2) delete [] arg2;
6880     }
6881     return resultobj;
6882     fail:
6883     {
6884         if (arg2) delete [] arg2;
6885     }
6886     return NULL;
6887 }
6888
6889
6890 static PyObject *_wrap_delete_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6891     PyObject *resultobj;
6892     wxRegion *arg1 = (wxRegion *) 0 ;
6893     PyObject * obj0 = 0 ;
6894     char *kwnames[] = {
6895         (char *) "self", NULL
6896     };
6897
6898     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Region",kwnames,&obj0)) goto fail;
6899     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6900     if (SWIG_arg_fail(1)) SWIG_fail;
6901     {
6902         PyThreadState* __tstate = wxPyBeginAllowThreads();
6903         delete arg1;
6904
6905         wxPyEndAllowThreads(__tstate);
6906         if (PyErr_Occurred()) SWIG_fail;
6907     }
6908     Py_INCREF(Py_None); resultobj = Py_None;
6909     return resultobj;
6910     fail:
6911     return NULL;
6912 }
6913
6914
6915 static PyObject *_wrap_Region_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
6916     PyObject *resultobj;
6917     wxRegion *arg1 = (wxRegion *) 0 ;
6918     PyObject * obj0 = 0 ;
6919     char *kwnames[] = {
6920         (char *) "self", NULL
6921     };
6922
6923     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_Clear",kwnames,&obj0)) goto fail;
6924     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6925     if (SWIG_arg_fail(1)) SWIG_fail;
6926     {
6927         PyThreadState* __tstate = wxPyBeginAllowThreads();
6928         (arg1)->Clear();
6929
6930         wxPyEndAllowThreads(__tstate);
6931         if (PyErr_Occurred()) SWIG_fail;
6932     }
6933     Py_INCREF(Py_None); resultobj = Py_None;
6934     return resultobj;
6935     fail:
6936     return NULL;
6937 }
6938
6939
6940 static PyObject *_wrap_Region_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
6941     PyObject *resultobj;
6942     wxRegion *arg1 = (wxRegion *) 0 ;
6943     int arg2 ;
6944     int arg3 ;
6945     bool result;
6946     PyObject * obj0 = 0 ;
6947     PyObject * obj1 = 0 ;
6948     PyObject * obj2 = 0 ;
6949     char *kwnames[] = {
6950         (char *) "self",(char *) "x",(char *) "y", NULL
6951     };
6952
6953     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Offset",kwnames,&obj0,&obj1,&obj2)) goto fail;
6954     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6955     if (SWIG_arg_fail(1)) SWIG_fail;
6956     {
6957         arg2 = (int)(SWIG_As_int(obj1));
6958         if (SWIG_arg_fail(2)) SWIG_fail;
6959     }
6960     {
6961         arg3 = (int)(SWIG_As_int(obj2));
6962         if (SWIG_arg_fail(3)) SWIG_fail;
6963     }
6964     {
6965         PyThreadState* __tstate = wxPyBeginAllowThreads();
6966         result = (bool)(arg1)->Offset(arg2,arg3);
6967
6968         wxPyEndAllowThreads(__tstate);
6969         if (PyErr_Occurred()) SWIG_fail;
6970     }
6971     {
6972         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6973     }
6974     return resultobj;
6975     fail:
6976     return NULL;
6977 }
6978
6979
6980 static PyObject *_wrap_Region_Contains(PyObject *, PyObject *args, PyObject *kwargs) {
6981     PyObject *resultobj;
6982     wxRegion *arg1 = (wxRegion *) 0 ;
6983     int arg2 ;
6984     int arg3 ;
6985     wxRegionContain result;
6986     PyObject * obj0 = 0 ;
6987     PyObject * obj1 = 0 ;
6988     PyObject * obj2 = 0 ;
6989     char *kwnames[] = {
6990         (char *) "self",(char *) "x",(char *) "y", NULL
6991     };
6992
6993     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Contains",kwnames,&obj0,&obj1,&obj2)) goto fail;
6994     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6995     if (SWIG_arg_fail(1)) SWIG_fail;
6996     {
6997         arg2 = (int)(SWIG_As_int(obj1));
6998         if (SWIG_arg_fail(2)) SWIG_fail;
6999     }
7000     {
7001         arg3 = (int)(SWIG_As_int(obj2));
7002         if (SWIG_arg_fail(3)) SWIG_fail;
7003     }
7004     {
7005         PyThreadState* __tstate = wxPyBeginAllowThreads();
7006         result = (wxRegionContain)(arg1)->Contains(arg2,arg3);
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_ContainsPoint(PyObject *, PyObject *args, PyObject *kwargs) {
7019     PyObject *resultobj;
7020     wxRegion *arg1 = (wxRegion *) 0 ;
7021     wxPoint *arg2 = 0 ;
7022     wxRegionContain result;
7023     wxPoint temp2 ;
7024     PyObject * obj0 = 0 ;
7025     PyObject * obj1 = 0 ;
7026     char *kwnames[] = {
7027         (char *) "self",(char *) "pt", NULL
7028     };
7029
7030     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsPoint",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 ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7036     }
7037     {
7038         PyThreadState* __tstate = wxPyBeginAllowThreads();
7039         result = (wxRegionContain)(arg1)->Contains((wxPoint 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_ContainsRect(PyObject *, PyObject *args, PyObject *kwargs) {
7052     PyObject *resultobj;
7053     wxRegion *arg1 = (wxRegion *) 0 ;
7054     wxRect *arg2 = 0 ;
7055     wxRegionContain result;
7056     wxRect temp2 ;
7057     PyObject * obj0 = 0 ;
7058     PyObject * obj1 = 0 ;
7059     char *kwnames[] = {
7060         (char *) "self",(char *) "rect", NULL
7061     };
7062
7063     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsRect",kwnames,&obj0,&obj1)) goto fail;
7064     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7065     if (SWIG_arg_fail(1)) SWIG_fail;
7066     {
7067         arg2 = &temp2;
7068         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7069     }
7070     {
7071         PyThreadState* __tstate = wxPyBeginAllowThreads();
7072         result = (wxRegionContain)(arg1)->Contains((wxRect const &)*arg2);
7073
7074         wxPyEndAllowThreads(__tstate);
7075         if (PyErr_Occurred()) SWIG_fail;
7076     }
7077     resultobj = SWIG_From_int((result));
7078     return resultobj;
7079     fail:
7080     return NULL;
7081 }
7082
7083
7084 static PyObject *_wrap_Region_ContainsRectDim(PyObject *, PyObject *args, PyObject *kwargs) {
7085     PyObject *resultobj;
7086     wxRegion *arg1 = (wxRegion *) 0 ;
7087     int arg2 ;
7088     int arg3 ;
7089     int arg4 ;
7090     int arg5 ;
7091     wxRegionContain result;
7092     PyObject * obj0 = 0 ;
7093     PyObject * obj1 = 0 ;
7094     PyObject * obj2 = 0 ;
7095     PyObject * obj3 = 0 ;
7096     PyObject * obj4 = 0 ;
7097     char *kwnames[] = {
7098         (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
7099     };
7100
7101     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_ContainsRectDim",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7102     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7103     if (SWIG_arg_fail(1)) SWIG_fail;
7104     {
7105         arg2 = (int)(SWIG_As_int(obj1));
7106         if (SWIG_arg_fail(2)) SWIG_fail;
7107     }
7108     {
7109         arg3 = (int)(SWIG_As_int(obj2));
7110         if (SWIG_arg_fail(3)) SWIG_fail;
7111     }
7112     {
7113         arg4 = (int)(SWIG_As_int(obj3));
7114         if (SWIG_arg_fail(4)) SWIG_fail;
7115     }
7116     {
7117         arg5 = (int)(SWIG_As_int(obj4));
7118         if (SWIG_arg_fail(5)) SWIG_fail;
7119     }
7120     {
7121         PyThreadState* __tstate = wxPyBeginAllowThreads();
7122         result = (wxRegionContain)(arg1)->Contains(arg2,arg3,arg4,arg5);
7123
7124         wxPyEndAllowThreads(__tstate);
7125         if (PyErr_Occurred()) SWIG_fail;
7126     }
7127     resultobj = SWIG_From_int((result));
7128     return resultobj;
7129     fail:
7130     return NULL;
7131 }
7132
7133
7134 static PyObject *_wrap_Region_GetBox(PyObject *, PyObject *args, PyObject *kwargs) {
7135     PyObject *resultobj;
7136     wxRegion *arg1 = (wxRegion *) 0 ;
7137     wxRect result;
7138     PyObject * obj0 = 0 ;
7139     char *kwnames[] = {
7140         (char *) "self", NULL
7141     };
7142
7143     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_GetBox",kwnames,&obj0)) goto fail;
7144     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7145     if (SWIG_arg_fail(1)) SWIG_fail;
7146     {
7147         PyThreadState* __tstate = wxPyBeginAllowThreads();
7148         result = (arg1)->GetBox();
7149
7150         wxPyEndAllowThreads(__tstate);
7151         if (PyErr_Occurred()) SWIG_fail;
7152     }
7153     {
7154         wxRect * resultptr;
7155         resultptr = new wxRect((wxRect &)(result));
7156         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
7157     }
7158     return resultobj;
7159     fail:
7160     return NULL;
7161 }
7162
7163
7164 static PyObject *_wrap_Region_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
7165     PyObject *resultobj;
7166     wxRegion *arg1 = (wxRegion *) 0 ;
7167     int arg2 ;
7168     int arg3 ;
7169     int arg4 ;
7170     int arg5 ;
7171     bool result;
7172     PyObject * obj0 = 0 ;
7173     PyObject * obj1 = 0 ;
7174     PyObject * obj2 = 0 ;
7175     PyObject * obj3 = 0 ;
7176     PyObject * obj4 = 0 ;
7177     char *kwnames[] = {
7178         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7179     };
7180
7181     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Intersect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7182     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7183     if (SWIG_arg_fail(1)) SWIG_fail;
7184     {
7185         arg2 = (int)(SWIG_As_int(obj1));
7186         if (SWIG_arg_fail(2)) SWIG_fail;
7187     }
7188     {
7189         arg3 = (int)(SWIG_As_int(obj2));
7190         if (SWIG_arg_fail(3)) SWIG_fail;
7191     }
7192     {
7193         arg4 = (int)(SWIG_As_int(obj3));
7194         if (SWIG_arg_fail(4)) SWIG_fail;
7195     }
7196     {
7197         arg5 = (int)(SWIG_As_int(obj4));
7198         if (SWIG_arg_fail(5)) SWIG_fail;
7199     }
7200     {
7201         PyThreadState* __tstate = wxPyBeginAllowThreads();
7202         result = (bool)(arg1)->Intersect(arg2,arg3,arg4,arg5);
7203
7204         wxPyEndAllowThreads(__tstate);
7205         if (PyErr_Occurred()) SWIG_fail;
7206     }
7207     {
7208         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7209     }
7210     return resultobj;
7211     fail:
7212     return NULL;
7213 }
7214
7215
7216 static PyObject *_wrap_Region_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
7217     PyObject *resultobj;
7218     wxRegion *arg1 = (wxRegion *) 0 ;
7219     wxRect *arg2 = 0 ;
7220     bool result;
7221     wxRect temp2 ;
7222     PyObject * obj0 = 0 ;
7223     PyObject * obj1 = 0 ;
7224     char *kwnames[] = {
7225         (char *) "self",(char *) "rect", NULL
7226     };
7227
7228     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRect",kwnames,&obj0,&obj1)) goto fail;
7229     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7230     if (SWIG_arg_fail(1)) SWIG_fail;
7231     {
7232         arg2 = &temp2;
7233         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7234     }
7235     {
7236         PyThreadState* __tstate = wxPyBeginAllowThreads();
7237         result = (bool)(arg1)->Intersect((wxRect const &)*arg2);
7238
7239         wxPyEndAllowThreads(__tstate);
7240         if (PyErr_Occurred()) SWIG_fail;
7241     }
7242     {
7243         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7244     }
7245     return resultobj;
7246     fail:
7247     return NULL;
7248 }
7249
7250
7251 static PyObject *_wrap_Region_IntersectRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7252     PyObject *resultobj;
7253     wxRegion *arg1 = (wxRegion *) 0 ;
7254     wxRegion *arg2 = 0 ;
7255     bool result;
7256     PyObject * obj0 = 0 ;
7257     PyObject * obj1 = 0 ;
7258     char *kwnames[] = {
7259         (char *) "self",(char *) "region", NULL
7260     };
7261
7262     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRegion",kwnames,&obj0,&obj1)) goto fail;
7263     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7264     if (SWIG_arg_fail(1)) SWIG_fail;
7265     {
7266         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7267         if (SWIG_arg_fail(2)) SWIG_fail;
7268         if (arg2 == NULL) {
7269             SWIG_null_ref("wxRegion");
7270         }
7271         if (SWIG_arg_fail(2)) SWIG_fail;
7272     }
7273     {
7274         PyThreadState* __tstate = wxPyBeginAllowThreads();
7275         result = (bool)(arg1)->Intersect((wxRegion const &)*arg2);
7276
7277         wxPyEndAllowThreads(__tstate);
7278         if (PyErr_Occurred()) SWIG_fail;
7279     }
7280     {
7281         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7282     }
7283     return resultobj;
7284     fail:
7285     return NULL;
7286 }
7287
7288
7289 static PyObject *_wrap_Region_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
7290     PyObject *resultobj;
7291     wxRegion *arg1 = (wxRegion *) 0 ;
7292     bool result;
7293     PyObject * obj0 = 0 ;
7294     char *kwnames[] = {
7295         (char *) "self", NULL
7296     };
7297
7298     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_IsEmpty",kwnames,&obj0)) goto fail;
7299     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7300     if (SWIG_arg_fail(1)) SWIG_fail;
7301     {
7302         PyThreadState* __tstate = wxPyBeginAllowThreads();
7303         result = (bool)(arg1)->IsEmpty();
7304
7305         wxPyEndAllowThreads(__tstate);
7306         if (PyErr_Occurred()) SWIG_fail;
7307     }
7308     {
7309         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7310     }
7311     return resultobj;
7312     fail:
7313     return NULL;
7314 }
7315
7316
7317 static PyObject *_wrap_Region_Union(PyObject *, PyObject *args, PyObject *kwargs) {
7318     PyObject *resultobj;
7319     wxRegion *arg1 = (wxRegion *) 0 ;
7320     int arg2 ;
7321     int arg3 ;
7322     int arg4 ;
7323     int arg5 ;
7324     bool result;
7325     PyObject * obj0 = 0 ;
7326     PyObject * obj1 = 0 ;
7327     PyObject * obj2 = 0 ;
7328     PyObject * obj3 = 0 ;
7329     PyObject * obj4 = 0 ;
7330     char *kwnames[] = {
7331         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7332     };
7333
7334     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Union",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7335     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7336     if (SWIG_arg_fail(1)) SWIG_fail;
7337     {
7338         arg2 = (int)(SWIG_As_int(obj1));
7339         if (SWIG_arg_fail(2)) SWIG_fail;
7340     }
7341     {
7342         arg3 = (int)(SWIG_As_int(obj2));
7343         if (SWIG_arg_fail(3)) SWIG_fail;
7344     }
7345     {
7346         arg4 = (int)(SWIG_As_int(obj3));
7347         if (SWIG_arg_fail(4)) SWIG_fail;
7348     }
7349     {
7350         arg5 = (int)(SWIG_As_int(obj4));
7351         if (SWIG_arg_fail(5)) SWIG_fail;
7352     }
7353     {
7354         PyThreadState* __tstate = wxPyBeginAllowThreads();
7355         result = (bool)(arg1)->Union(arg2,arg3,arg4,arg5);
7356
7357         wxPyEndAllowThreads(__tstate);
7358         if (PyErr_Occurred()) SWIG_fail;
7359     }
7360     {
7361         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7362     }
7363     return resultobj;
7364     fail:
7365     return NULL;
7366 }
7367
7368
7369 static PyObject *_wrap_Region_UnionRect(PyObject *, PyObject *args, PyObject *kwargs) {
7370     PyObject *resultobj;
7371     wxRegion *arg1 = (wxRegion *) 0 ;
7372     wxRect *arg2 = 0 ;
7373     bool result;
7374     wxRect temp2 ;
7375     PyObject * obj0 = 0 ;
7376     PyObject * obj1 = 0 ;
7377     char *kwnames[] = {
7378         (char *) "self",(char *) "rect", NULL
7379     };
7380
7381     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRect",kwnames,&obj0,&obj1)) goto fail;
7382     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7383     if (SWIG_arg_fail(1)) SWIG_fail;
7384     {
7385         arg2 = &temp2;
7386         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7387     }
7388     {
7389         PyThreadState* __tstate = wxPyBeginAllowThreads();
7390         result = (bool)(arg1)->Union((wxRect const &)*arg2);
7391
7392         wxPyEndAllowThreads(__tstate);
7393         if (PyErr_Occurred()) SWIG_fail;
7394     }
7395     {
7396         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7397     }
7398     return resultobj;
7399     fail:
7400     return NULL;
7401 }
7402
7403
7404 static PyObject *_wrap_Region_UnionRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7405     PyObject *resultobj;
7406     wxRegion *arg1 = (wxRegion *) 0 ;
7407     wxRegion *arg2 = 0 ;
7408     bool result;
7409     PyObject * obj0 = 0 ;
7410     PyObject * obj1 = 0 ;
7411     char *kwnames[] = {
7412         (char *) "self",(char *) "region", NULL
7413     };
7414
7415     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRegion",kwnames,&obj0,&obj1)) goto fail;
7416     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7417     if (SWIG_arg_fail(1)) SWIG_fail;
7418     {
7419         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7420         if (SWIG_arg_fail(2)) SWIG_fail;
7421         if (arg2 == NULL) {
7422             SWIG_null_ref("wxRegion");
7423         }
7424         if (SWIG_arg_fail(2)) SWIG_fail;
7425     }
7426     {
7427         PyThreadState* __tstate = wxPyBeginAllowThreads();
7428         result = (bool)(arg1)->Union((wxRegion const &)*arg2);
7429
7430         wxPyEndAllowThreads(__tstate);
7431         if (PyErr_Occurred()) SWIG_fail;
7432     }
7433     {
7434         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7435     }
7436     return resultobj;
7437     fail:
7438     return NULL;
7439 }
7440
7441
7442 static PyObject *_wrap_Region_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
7443     PyObject *resultobj;
7444     wxRegion *arg1 = (wxRegion *) 0 ;
7445     int arg2 ;
7446     int arg3 ;
7447     int arg4 ;
7448     int arg5 ;
7449     bool result;
7450     PyObject * obj0 = 0 ;
7451     PyObject * obj1 = 0 ;
7452     PyObject * obj2 = 0 ;
7453     PyObject * obj3 = 0 ;
7454     PyObject * obj4 = 0 ;
7455     char *kwnames[] = {
7456         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7457     };
7458
7459     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Subtract",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7460     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7461     if (SWIG_arg_fail(1)) SWIG_fail;
7462     {
7463         arg2 = (int)(SWIG_As_int(obj1));
7464         if (SWIG_arg_fail(2)) SWIG_fail;
7465     }
7466     {
7467         arg3 = (int)(SWIG_As_int(obj2));
7468         if (SWIG_arg_fail(3)) SWIG_fail;
7469     }
7470     {
7471         arg4 = (int)(SWIG_As_int(obj3));
7472         if (SWIG_arg_fail(4)) SWIG_fail;
7473     }
7474     {
7475         arg5 = (int)(SWIG_As_int(obj4));
7476         if (SWIG_arg_fail(5)) SWIG_fail;
7477     }
7478     {
7479         PyThreadState* __tstate = wxPyBeginAllowThreads();
7480         result = (bool)(arg1)->Subtract(arg2,arg3,arg4,arg5);
7481
7482         wxPyEndAllowThreads(__tstate);
7483         if (PyErr_Occurred()) SWIG_fail;
7484     }
7485     {
7486         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7487     }
7488     return resultobj;
7489     fail:
7490     return NULL;
7491 }
7492
7493
7494 static PyObject *_wrap_Region_SubtractRect(PyObject *, PyObject *args, PyObject *kwargs) {
7495     PyObject *resultobj;
7496     wxRegion *arg1 = (wxRegion *) 0 ;
7497     wxRect *arg2 = 0 ;
7498     bool result;
7499     wxRect temp2 ;
7500     PyObject * obj0 = 0 ;
7501     PyObject * obj1 = 0 ;
7502     char *kwnames[] = {
7503         (char *) "self",(char *) "rect", NULL
7504     };
7505
7506     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRect",kwnames,&obj0,&obj1)) goto fail;
7507     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7508     if (SWIG_arg_fail(1)) SWIG_fail;
7509     {
7510         arg2 = &temp2;
7511         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7512     }
7513     {
7514         PyThreadState* __tstate = wxPyBeginAllowThreads();
7515         result = (bool)(arg1)->Subtract((wxRect const &)*arg2);
7516
7517         wxPyEndAllowThreads(__tstate);
7518         if (PyErr_Occurred()) SWIG_fail;
7519     }
7520     {
7521         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7522     }
7523     return resultobj;
7524     fail:
7525     return NULL;
7526 }
7527
7528
7529 static PyObject *_wrap_Region_SubtractRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7530     PyObject *resultobj;
7531     wxRegion *arg1 = (wxRegion *) 0 ;
7532     wxRegion *arg2 = 0 ;
7533     bool result;
7534     PyObject * obj0 = 0 ;
7535     PyObject * obj1 = 0 ;
7536     char *kwnames[] = {
7537         (char *) "self",(char *) "region", NULL
7538     };
7539
7540     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRegion",kwnames,&obj0,&obj1)) goto fail;
7541     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7542     if (SWIG_arg_fail(1)) SWIG_fail;
7543     {
7544         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7545         if (SWIG_arg_fail(2)) SWIG_fail;
7546         if (arg2 == NULL) {
7547             SWIG_null_ref("wxRegion");
7548         }
7549         if (SWIG_arg_fail(2)) SWIG_fail;
7550     }
7551     {
7552         PyThreadState* __tstate = wxPyBeginAllowThreads();
7553         result = (bool)(arg1)->Subtract((wxRegion const &)*arg2);
7554
7555         wxPyEndAllowThreads(__tstate);
7556         if (PyErr_Occurred()) SWIG_fail;
7557     }
7558     {
7559         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7560     }
7561     return resultobj;
7562     fail:
7563     return NULL;
7564 }
7565
7566
7567 static PyObject *_wrap_Region_Xor(PyObject *, PyObject *args, PyObject *kwargs) {
7568     PyObject *resultobj;
7569     wxRegion *arg1 = (wxRegion *) 0 ;
7570     int arg2 ;
7571     int arg3 ;
7572     int arg4 ;
7573     int arg5 ;
7574     bool result;
7575     PyObject * obj0 = 0 ;
7576     PyObject * obj1 = 0 ;
7577     PyObject * obj2 = 0 ;
7578     PyObject * obj3 = 0 ;
7579     PyObject * obj4 = 0 ;
7580     char *kwnames[] = {
7581         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7582     };
7583
7584     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Xor",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7585     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7586     if (SWIG_arg_fail(1)) SWIG_fail;
7587     {
7588         arg2 = (int)(SWIG_As_int(obj1));
7589         if (SWIG_arg_fail(2)) SWIG_fail;
7590     }
7591     {
7592         arg3 = (int)(SWIG_As_int(obj2));
7593         if (SWIG_arg_fail(3)) SWIG_fail;
7594     }
7595     {
7596         arg4 = (int)(SWIG_As_int(obj3));
7597         if (SWIG_arg_fail(4)) SWIG_fail;
7598     }
7599     {
7600         arg5 = (int)(SWIG_As_int(obj4));
7601         if (SWIG_arg_fail(5)) SWIG_fail;
7602     }
7603     {
7604         PyThreadState* __tstate = wxPyBeginAllowThreads();
7605         result = (bool)(arg1)->Xor(arg2,arg3,arg4,arg5);
7606
7607         wxPyEndAllowThreads(__tstate);
7608         if (PyErr_Occurred()) SWIG_fail;
7609     }
7610     {
7611         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7612     }
7613     return resultobj;
7614     fail:
7615     return NULL;
7616 }
7617
7618
7619 static PyObject *_wrap_Region_XorRect(PyObject *, PyObject *args, PyObject *kwargs) {
7620     PyObject *resultobj;
7621     wxRegion *arg1 = (wxRegion *) 0 ;
7622     wxRect *arg2 = 0 ;
7623     bool result;
7624     wxRect temp2 ;
7625     PyObject * obj0 = 0 ;
7626     PyObject * obj1 = 0 ;
7627     char *kwnames[] = {
7628         (char *) "self",(char *) "rect", NULL
7629     };
7630
7631     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRect",kwnames,&obj0,&obj1)) goto fail;
7632     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7633     if (SWIG_arg_fail(1)) SWIG_fail;
7634     {
7635         arg2 = &temp2;
7636         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7637     }
7638     {
7639         PyThreadState* __tstate = wxPyBeginAllowThreads();
7640         result = (bool)(arg1)->Xor((wxRect const &)*arg2);
7641
7642         wxPyEndAllowThreads(__tstate);
7643         if (PyErr_Occurred()) SWIG_fail;
7644     }
7645     {
7646         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7647     }
7648     return resultobj;
7649     fail:
7650     return NULL;
7651 }
7652
7653
7654 static PyObject *_wrap_Region_XorRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7655     PyObject *resultobj;
7656     wxRegion *arg1 = (wxRegion *) 0 ;
7657     wxRegion *arg2 = 0 ;
7658     bool result;
7659     PyObject * obj0 = 0 ;
7660     PyObject * obj1 = 0 ;
7661     char *kwnames[] = {
7662         (char *) "self",(char *) "region", NULL
7663     };
7664
7665     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRegion",kwnames,&obj0,&obj1)) goto fail;
7666     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7667     if (SWIG_arg_fail(1)) SWIG_fail;
7668     {
7669         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7670         if (SWIG_arg_fail(2)) SWIG_fail;
7671         if (arg2 == NULL) {
7672             SWIG_null_ref("wxRegion");
7673         }
7674         if (SWIG_arg_fail(2)) SWIG_fail;
7675     }
7676     {
7677         PyThreadState* __tstate = wxPyBeginAllowThreads();
7678         result = (bool)(arg1)->Xor((wxRegion const &)*arg2);
7679
7680         wxPyEndAllowThreads(__tstate);
7681         if (PyErr_Occurred()) SWIG_fail;
7682     }
7683     {
7684         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7685     }
7686     return resultobj;
7687     fail:
7688     return NULL;
7689 }
7690
7691
7692 static PyObject *_wrap_Region_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7693     PyObject *resultobj;
7694     wxRegion *arg1 = (wxRegion *) 0 ;
7695     SwigValueWrapper<wxBitmap > result;
7696     PyObject * obj0 = 0 ;
7697     char *kwnames[] = {
7698         (char *) "self", NULL
7699     };
7700
7701     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_ConvertToBitmap",kwnames,&obj0)) goto fail;
7702     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7703     if (SWIG_arg_fail(1)) SWIG_fail;
7704     {
7705         PyThreadState* __tstate = wxPyBeginAllowThreads();
7706         result = (arg1)->ConvertToBitmap();
7707
7708         wxPyEndAllowThreads(__tstate);
7709         if (PyErr_Occurred()) SWIG_fail;
7710     }
7711     {
7712         wxBitmap * resultptr;
7713         resultptr = new wxBitmap((wxBitmap &)(result));
7714         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
7715     }
7716     return resultobj;
7717     fail:
7718     return NULL;
7719 }
7720
7721
7722 static PyObject *_wrap_Region_UnionBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7723     PyObject *resultobj;
7724     wxRegion *arg1 = (wxRegion *) 0 ;
7725     wxBitmap *arg2 = 0 ;
7726     bool result;
7727     PyObject * obj0 = 0 ;
7728     PyObject * obj1 = 0 ;
7729     char *kwnames[] = {
7730         (char *) "self",(char *) "bmp", NULL
7731     };
7732
7733     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionBitmap",kwnames,&obj0,&obj1)) goto fail;
7734     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7735     if (SWIG_arg_fail(1)) SWIG_fail;
7736     {
7737         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7738         if (SWIG_arg_fail(2)) SWIG_fail;
7739         if (arg2 == NULL) {
7740             SWIG_null_ref("wxBitmap");
7741         }
7742         if (SWIG_arg_fail(2)) SWIG_fail;
7743     }
7744     {
7745         PyThreadState* __tstate = wxPyBeginAllowThreads();
7746         result = (bool)(arg1)->Union((wxBitmap const &)*arg2);
7747
7748         wxPyEndAllowThreads(__tstate);
7749         if (PyErr_Occurred()) SWIG_fail;
7750     }
7751     {
7752         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7753     }
7754     return resultobj;
7755     fail:
7756     return NULL;
7757 }
7758
7759
7760 static PyObject *_wrap_Region_UnionBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
7761     PyObject *resultobj;
7762     wxRegion *arg1 = (wxRegion *) 0 ;
7763     wxBitmap *arg2 = 0 ;
7764     wxColour *arg3 = 0 ;
7765     int arg4 = (int) 0 ;
7766     bool result;
7767     wxColour temp3 ;
7768     PyObject * obj0 = 0 ;
7769     PyObject * obj1 = 0 ;
7770     PyObject * obj2 = 0 ;
7771     PyObject * obj3 = 0 ;
7772     char *kwnames[] = {
7773         (char *) "self",(char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
7774     };
7775
7776     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Region_UnionBitmapColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7777     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7778     if (SWIG_arg_fail(1)) SWIG_fail;
7779     {
7780         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7781         if (SWIG_arg_fail(2)) SWIG_fail;
7782         if (arg2 == NULL) {
7783             SWIG_null_ref("wxBitmap");
7784         }
7785         if (SWIG_arg_fail(2)) SWIG_fail;
7786     }
7787     {
7788         arg3 = &temp3;
7789         if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
7790     }
7791     if (obj3) {
7792         {
7793             arg4 = (int)(SWIG_As_int(obj3));
7794             if (SWIG_arg_fail(4)) SWIG_fail;
7795         }
7796     }
7797     {
7798         PyThreadState* __tstate = wxPyBeginAllowThreads();
7799         result = (bool)(arg1)->Union((wxBitmap const &)*arg2,(wxColour const &)*arg3,arg4);
7800
7801         wxPyEndAllowThreads(__tstate);
7802         if (PyErr_Occurred()) SWIG_fail;
7803     }
7804     {
7805         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7806     }
7807     return resultobj;
7808     fail:
7809     return NULL;
7810 }
7811
7812
7813 static PyObject * Region_swigregister(PyObject *, PyObject *args) {
7814     PyObject *obj;
7815     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7816     SWIG_TypeClientData(SWIGTYPE_p_wxRegion, obj);
7817     Py_INCREF(obj);
7818     return Py_BuildValue((char *)"");
7819 }
7820 static PyObject *_wrap_new_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7821     PyObject *resultobj;
7822     wxRegion *arg1 = 0 ;
7823     wxRegionIterator *result;
7824     PyObject * obj0 = 0 ;
7825     char *kwnames[] = {
7826         (char *) "region", NULL
7827     };
7828
7829     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionIterator",kwnames,&obj0)) goto fail;
7830     {
7831         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7832         if (SWIG_arg_fail(1)) SWIG_fail;
7833         if (arg1 == NULL) {
7834             SWIG_null_ref("wxRegion");
7835         }
7836         if (SWIG_arg_fail(1)) SWIG_fail;
7837     }
7838     {
7839         if (!wxPyCheckForApp()) SWIG_fail;
7840         PyThreadState* __tstate = wxPyBeginAllowThreads();
7841         result = (wxRegionIterator *)new wxRegionIterator((wxRegion const &)*arg1);
7842
7843         wxPyEndAllowThreads(__tstate);
7844         if (PyErr_Occurred()) SWIG_fail;
7845     }
7846     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegionIterator, 1);
7847     return resultobj;
7848     fail:
7849     return NULL;
7850 }
7851
7852
7853 static PyObject *_wrap_delete_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7854     PyObject *resultobj;
7855     wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7856     PyObject * obj0 = 0 ;
7857     char *kwnames[] = {
7858         (char *) "self", NULL
7859     };
7860
7861     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RegionIterator",kwnames,&obj0)) goto fail;
7862     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7863     if (SWIG_arg_fail(1)) SWIG_fail;
7864     {
7865         PyThreadState* __tstate = wxPyBeginAllowThreads();
7866         delete arg1;
7867
7868         wxPyEndAllowThreads(__tstate);
7869         if (PyErr_Occurred()) SWIG_fail;
7870     }
7871     Py_INCREF(Py_None); resultobj = Py_None;
7872     return resultobj;
7873     fail:
7874     return NULL;
7875 }
7876
7877
7878 static PyObject *_wrap_RegionIterator_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
7879     PyObject *resultobj;
7880     wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7881     int result;
7882     PyObject * obj0 = 0 ;
7883     char *kwnames[] = {
7884         (char *) "self", NULL
7885     };
7886
7887     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetX",kwnames,&obj0)) goto fail;
7888     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7889     if (SWIG_arg_fail(1)) SWIG_fail;
7890     {
7891         PyThreadState* __tstate = wxPyBeginAllowThreads();
7892         result = (int)(arg1)->GetX();
7893
7894         wxPyEndAllowThreads(__tstate);
7895         if (PyErr_Occurred()) SWIG_fail;
7896     }
7897     {
7898         resultobj = SWIG_From_int((int)(result));
7899     }
7900     return resultobj;
7901     fail:
7902     return NULL;
7903 }
7904
7905
7906 static PyObject *_wrap_RegionIterator_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
7907     PyObject *resultobj;
7908     wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7909     int result;
7910     PyObject * obj0 = 0 ;
7911     char *kwnames[] = {
7912         (char *) "self", NULL
7913     };
7914
7915     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetY",kwnames,&obj0)) goto fail;
7916     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7917     if (SWIG_arg_fail(1)) SWIG_fail;
7918     {
7919         PyThreadState* __tstate = wxPyBeginAllowThreads();
7920         result = (int)(arg1)->GetY();
7921
7922         wxPyEndAllowThreads(__tstate);
7923         if (PyErr_Occurred()) SWIG_fail;
7924     }
7925     {
7926         resultobj = SWIG_From_int((int)(result));
7927     }
7928     return resultobj;
7929     fail:
7930     return NULL;
7931 }
7932
7933
7934 static PyObject *_wrap_RegionIterator_GetW(PyObject *, PyObject *args, PyObject *kwargs) {
7935     PyObject *resultobj;
7936     wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7937     int result;
7938     PyObject * obj0 = 0 ;
7939     char *kwnames[] = {
7940         (char *) "self", NULL
7941     };
7942
7943     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetW",kwnames,&obj0)) goto fail;
7944     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7945     if (SWIG_arg_fail(1)) SWIG_fail;
7946     {
7947         PyThreadState* __tstate = wxPyBeginAllowThreads();
7948         result = (int)(arg1)->GetW();
7949
7950         wxPyEndAllowThreads(__tstate);
7951         if (PyErr_Occurred()) SWIG_fail;
7952     }
7953     {
7954         resultobj = SWIG_From_int((int)(result));
7955     }
7956     return resultobj;
7957     fail:
7958     return NULL;
7959 }
7960
7961
7962 static PyObject *_wrap_RegionIterator_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
7963     PyObject *resultobj;
7964     wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7965     int result;
7966     PyObject * obj0 = 0 ;
7967     char *kwnames[] = {
7968         (char *) "self", NULL
7969     };
7970
7971     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetWidth",kwnames,&obj0)) goto fail;
7972     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7973     if (SWIG_arg_fail(1)) SWIG_fail;
7974     {
7975         PyThreadState* __tstate = wxPyBeginAllowThreads();
7976         result = (int)(arg1)->GetWidth();
7977
7978         wxPyEndAllowThreads(__tstate);
7979         if (PyErr_Occurred()) SWIG_fail;
7980     }
7981     {
7982         resultobj = SWIG_From_int((int)(result));
7983     }
7984     return resultobj;
7985     fail:
7986     return NULL;
7987 }
7988
7989
7990 static PyObject *_wrap_RegionIterator_GetH(PyObject *, PyObject *args, PyObject *kwargs) {
7991     PyObject *resultobj;
7992     wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7993     int result;
7994     PyObject * obj0 = 0 ;
7995     char *kwnames[] = {
7996         (char *) "self", NULL
7997     };
7998
7999     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetH",kwnames,&obj0)) goto fail;
8000     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8001     if (SWIG_arg_fail(1)) SWIG_fail;
8002     {
8003         PyThreadState* __tstate = wxPyBeginAllowThreads();
8004         result = (int)(arg1)->GetH();
8005
8006         wxPyEndAllowThreads(__tstate);
8007         if (PyErr_Occurred()) SWIG_fail;
8008     }
8009     {
8010         resultobj = SWIG_From_int((int)(result));
8011     }
8012     return resultobj;
8013     fail:
8014     return NULL;
8015 }
8016
8017
8018 static PyObject *_wrap_RegionIterator_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
8019     PyObject *resultobj;
8020     wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8021     int result;
8022     PyObject * obj0 = 0 ;
8023     char *kwnames[] = {
8024         (char *) "self", NULL
8025     };
8026
8027     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetHeight",kwnames,&obj0)) goto fail;
8028     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8029     if (SWIG_arg_fail(1)) SWIG_fail;
8030     {
8031         PyThreadState* __tstate = wxPyBeginAllowThreads();
8032         result = (int)(arg1)->GetHeight();
8033
8034         wxPyEndAllowThreads(__tstate);
8035         if (PyErr_Occurred()) SWIG_fail;
8036     }
8037     {
8038         resultobj = SWIG_From_int((int)(result));
8039     }
8040     return resultobj;
8041     fail:
8042     return NULL;
8043 }
8044
8045
8046 static PyObject *_wrap_RegionIterator_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
8047     PyObject *resultobj;
8048     wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8049     wxRect result;
8050     PyObject * obj0 = 0 ;
8051     char *kwnames[] = {
8052         (char *) "self", NULL
8053     };
8054
8055     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetRect",kwnames,&obj0)) goto fail;
8056     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8057     if (SWIG_arg_fail(1)) SWIG_fail;
8058     {
8059         PyThreadState* __tstate = wxPyBeginAllowThreads();
8060         result = (arg1)->GetRect();
8061
8062         wxPyEndAllowThreads(__tstate);
8063         if (PyErr_Occurred()) SWIG_fail;
8064     }
8065     {
8066         wxRect * resultptr;
8067         resultptr = new wxRect((wxRect &)(result));
8068         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
8069     }
8070     return resultobj;
8071     fail:
8072     return NULL;
8073 }
8074
8075
8076 static PyObject *_wrap_RegionIterator_HaveRects(PyObject *, PyObject *args, PyObject *kwargs) {
8077     PyObject *resultobj;
8078     wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8079     bool result;
8080     PyObject * obj0 = 0 ;
8081     char *kwnames[] = {
8082         (char *) "self", NULL
8083     };
8084
8085     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_HaveRects",kwnames,&obj0)) goto fail;
8086     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8087     if (SWIG_arg_fail(1)) SWIG_fail;
8088     {
8089         PyThreadState* __tstate = wxPyBeginAllowThreads();
8090         result = (bool)(arg1)->HaveRects();
8091
8092         wxPyEndAllowThreads(__tstate);
8093         if (PyErr_Occurred()) SWIG_fail;
8094     }
8095     {
8096         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8097     }
8098     return resultobj;
8099     fail:
8100     return NULL;
8101 }
8102
8103
8104 static PyObject *_wrap_RegionIterator_Reset(PyObject *, PyObject *args, PyObject *kwargs) {
8105     PyObject *resultobj;
8106     wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8107     PyObject * obj0 = 0 ;
8108     char *kwnames[] = {
8109         (char *) "self", NULL
8110     };
8111
8112     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Reset",kwnames,&obj0)) goto fail;
8113     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8114     if (SWIG_arg_fail(1)) SWIG_fail;
8115     {
8116         PyThreadState* __tstate = wxPyBeginAllowThreads();
8117         (arg1)->Reset();
8118
8119         wxPyEndAllowThreads(__tstate);
8120         if (PyErr_Occurred()) SWIG_fail;
8121     }
8122     Py_INCREF(Py_None); resultobj = Py_None;
8123     return resultobj;
8124     fail:
8125     return NULL;
8126 }
8127
8128
8129 static PyObject *_wrap_RegionIterator_Next(PyObject *, PyObject *args, PyObject *kwargs) {
8130     PyObject *resultobj;
8131     wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8132     PyObject * obj0 = 0 ;
8133     char *kwnames[] = {
8134         (char *) "self", NULL
8135     };
8136
8137     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Next",kwnames,&obj0)) goto fail;
8138     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8139     if (SWIG_arg_fail(1)) SWIG_fail;
8140     {
8141         PyThreadState* __tstate = wxPyBeginAllowThreads();
8142         wxRegionIterator_Next(arg1);
8143
8144         wxPyEndAllowThreads(__tstate);
8145         if (PyErr_Occurred()) SWIG_fail;
8146     }
8147     Py_INCREF(Py_None); resultobj = Py_None;
8148     return resultobj;
8149     fail:
8150     return NULL;
8151 }
8152
8153
8154 static PyObject *_wrap_RegionIterator___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
8155     PyObject *resultobj;
8156     wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8157     bool result;
8158     PyObject * obj0 = 0 ;
8159     char *kwnames[] = {
8160         (char *) "self", NULL
8161     };
8162
8163     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator___nonzero__",kwnames,&obj0)) goto fail;
8164     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8165     if (SWIG_arg_fail(1)) SWIG_fail;
8166     {
8167         PyThreadState* __tstate = wxPyBeginAllowThreads();
8168         result = (bool)wxRegionIterator___nonzero__(arg1);
8169
8170         wxPyEndAllowThreads(__tstate);
8171         if (PyErr_Occurred()) SWIG_fail;
8172     }
8173     {
8174         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8175     }
8176     return resultobj;
8177     fail:
8178     return NULL;
8179 }
8180
8181
8182 static PyObject * RegionIterator_swigregister(PyObject *, PyObject *args) {
8183     PyObject *obj;
8184     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8185     SWIG_TypeClientData(SWIGTYPE_p_wxRegionIterator, obj);
8186     Py_INCREF(obj);
8187     return Py_BuildValue((char *)"");
8188 }
8189 static PyObject *_wrap_new_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8190     PyObject *resultobj;
8191     wxNativeFontInfo *result;
8192     char *kwnames[] = {
8193         NULL
8194     };
8195
8196     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeFontInfo",kwnames)) goto fail;
8197     {
8198         PyThreadState* __tstate = wxPyBeginAllowThreads();
8199         result = (wxNativeFontInfo *)new wxNativeFontInfo();
8200
8201         wxPyEndAllowThreads(__tstate);
8202         if (PyErr_Occurred()) SWIG_fail;
8203     }
8204     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 1);
8205     return resultobj;
8206     fail:
8207     return NULL;
8208 }
8209
8210
8211 static PyObject *_wrap_delete_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8212     PyObject *resultobj;
8213     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8214     PyObject * obj0 = 0 ;
8215     char *kwnames[] = {
8216         (char *) "self", NULL
8217     };
8218
8219     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeFontInfo",kwnames,&obj0)) goto fail;
8220     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8221     if (SWIG_arg_fail(1)) SWIG_fail;
8222     {
8223         PyThreadState* __tstate = wxPyBeginAllowThreads();
8224         delete arg1;
8225
8226         wxPyEndAllowThreads(__tstate);
8227         if (PyErr_Occurred()) SWIG_fail;
8228     }
8229     Py_INCREF(Py_None); resultobj = Py_None;
8230     return resultobj;
8231     fail:
8232     return NULL;
8233 }
8234
8235
8236 static PyObject *_wrap_NativeFontInfo_Init(PyObject *, PyObject *args, PyObject *kwargs) {
8237     PyObject *resultobj;
8238     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8239     PyObject * obj0 = 0 ;
8240     char *kwnames[] = {
8241         (char *) "self", NULL
8242     };
8243
8244     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_Init",kwnames,&obj0)) goto fail;
8245     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8246     if (SWIG_arg_fail(1)) SWIG_fail;
8247     {
8248         PyThreadState* __tstate = wxPyBeginAllowThreads();
8249         (arg1)->Init();
8250
8251         wxPyEndAllowThreads(__tstate);
8252         if (PyErr_Occurred()) SWIG_fail;
8253     }
8254     Py_INCREF(Py_None); resultobj = Py_None;
8255     return resultobj;
8256     fail:
8257     return NULL;
8258 }
8259
8260
8261 static PyObject *_wrap_NativeFontInfo_InitFromFont(PyObject *, PyObject *args, PyObject *kwargs) {
8262     PyObject *resultobj;
8263     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8264     wxFont *arg2 = 0 ;
8265     PyObject * obj0 = 0 ;
8266     PyObject * obj1 = 0 ;
8267     char *kwnames[] = {
8268         (char *) "self",(char *) "font", NULL
8269     };
8270
8271     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_InitFromFont",kwnames,&obj0,&obj1)) goto fail;
8272     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8273     if (SWIG_arg_fail(1)) SWIG_fail;
8274     {
8275         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
8276         if (SWIG_arg_fail(2)) SWIG_fail;
8277         if (arg2 == NULL) {
8278             SWIG_null_ref("wxFont");
8279         }
8280         if (SWIG_arg_fail(2)) SWIG_fail;
8281     }
8282     {
8283         PyThreadState* __tstate = wxPyBeginAllowThreads();
8284         (arg1)->InitFromFont((wxFont const &)*arg2);
8285
8286         wxPyEndAllowThreads(__tstate);
8287         if (PyErr_Occurred()) SWIG_fail;
8288     }
8289     Py_INCREF(Py_None); resultobj = Py_None;
8290     return resultobj;
8291     fail:
8292     return NULL;
8293 }
8294
8295
8296 static PyObject *_wrap_NativeFontInfo_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
8297     PyObject *resultobj;
8298     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8299     int result;
8300     PyObject * obj0 = 0 ;
8301     char *kwnames[] = {
8302         (char *) "self", NULL
8303     };
8304
8305     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetPointSize",kwnames,&obj0)) goto fail;
8306     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8307     if (SWIG_arg_fail(1)) SWIG_fail;
8308     {
8309         PyThreadState* __tstate = wxPyBeginAllowThreads();
8310         result = (int)((wxNativeFontInfo const *)arg1)->GetPointSize();
8311
8312         wxPyEndAllowThreads(__tstate);
8313         if (PyErr_Occurred()) SWIG_fail;
8314     }
8315     {
8316         resultobj = SWIG_From_int((int)(result));
8317     }
8318     return resultobj;
8319     fail:
8320     return NULL;
8321 }
8322
8323
8324 static PyObject *_wrap_NativeFontInfo_GetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
8325     PyObject *resultobj;
8326     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8327     wxSize result;
8328     PyObject * obj0 = 0 ;
8329     char *kwnames[] = {
8330         (char *) "self", NULL
8331     };
8332
8333     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetPixelSize",kwnames,&obj0)) goto fail;
8334     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8335     if (SWIG_arg_fail(1)) SWIG_fail;
8336     {
8337         PyThreadState* __tstate = wxPyBeginAllowThreads();
8338         result = ((wxNativeFontInfo const *)arg1)->GetPixelSize();
8339
8340         wxPyEndAllowThreads(__tstate);
8341         if (PyErr_Occurred()) SWIG_fail;
8342     }
8343     {
8344         wxSize * resultptr;
8345         resultptr = new wxSize((wxSize &)(result));
8346         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
8347     }
8348     return resultobj;
8349     fail:
8350     return NULL;
8351 }
8352
8353
8354 static PyObject *_wrap_NativeFontInfo_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
8355     PyObject *resultobj;
8356     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8357     wxFontStyle result;
8358     PyObject * obj0 = 0 ;
8359     char *kwnames[] = {
8360         (char *) "self", NULL
8361     };
8362
8363     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetStyle",kwnames,&obj0)) goto fail;
8364     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8365     if (SWIG_arg_fail(1)) SWIG_fail;
8366     {
8367         PyThreadState* __tstate = wxPyBeginAllowThreads();
8368         result = (wxFontStyle)((wxNativeFontInfo const *)arg1)->GetStyle();
8369
8370         wxPyEndAllowThreads(__tstate);
8371         if (PyErr_Occurred()) SWIG_fail;
8372     }
8373     resultobj = SWIG_From_int((result));
8374     return resultobj;
8375     fail:
8376     return NULL;
8377 }
8378
8379
8380 static PyObject *_wrap_NativeFontInfo_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
8381     PyObject *resultobj;
8382     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8383     wxFontWeight result;
8384     PyObject * obj0 = 0 ;
8385     char *kwnames[] = {
8386         (char *) "self", NULL
8387     };
8388
8389     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetWeight",kwnames,&obj0)) goto fail;
8390     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8391     if (SWIG_arg_fail(1)) SWIG_fail;
8392     {
8393         PyThreadState* __tstate = wxPyBeginAllowThreads();
8394         result = (wxFontWeight)((wxNativeFontInfo const *)arg1)->GetWeight();
8395
8396         wxPyEndAllowThreads(__tstate);
8397         if (PyErr_Occurred()) SWIG_fail;
8398     }
8399     resultobj = SWIG_From_int((result));
8400     return resultobj;
8401     fail:
8402     return NULL;
8403 }
8404
8405
8406 static PyObject *_wrap_NativeFontInfo_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
8407     PyObject *resultobj;
8408     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8409     bool result;
8410     PyObject * obj0 = 0 ;
8411     char *kwnames[] = {
8412         (char *) "self", NULL
8413     };
8414
8415     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetUnderlined",kwnames,&obj0)) goto fail;
8416     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8417     if (SWIG_arg_fail(1)) SWIG_fail;
8418     {
8419         PyThreadState* __tstate = wxPyBeginAllowThreads();
8420         result = (bool)((wxNativeFontInfo const *)arg1)->GetUnderlined();
8421
8422         wxPyEndAllowThreads(__tstate);
8423         if (PyErr_Occurred()) SWIG_fail;
8424     }
8425     {
8426         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8427     }
8428     return resultobj;
8429     fail:
8430     return NULL;
8431 }
8432
8433
8434 static PyObject *_wrap_NativeFontInfo_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
8435     PyObject *resultobj;
8436     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8437     wxString result;
8438     PyObject * obj0 = 0 ;
8439     char *kwnames[] = {
8440         (char *) "self", NULL
8441     };
8442
8443     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFaceName",kwnames,&obj0)) goto fail;
8444     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8445     if (SWIG_arg_fail(1)) SWIG_fail;
8446     {
8447         PyThreadState* __tstate = wxPyBeginAllowThreads();
8448         result = ((wxNativeFontInfo const *)arg1)->GetFaceName();
8449
8450         wxPyEndAllowThreads(__tstate);
8451         if (PyErr_Occurred()) SWIG_fail;
8452     }
8453     {
8454 #if wxUSE_UNICODE
8455         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8456 #else
8457         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8458 #endif
8459     }
8460     return resultobj;
8461     fail:
8462     return NULL;
8463 }
8464
8465
8466 static PyObject *_wrap_NativeFontInfo_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
8467     PyObject *resultobj;
8468     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8469     wxFontFamily result;
8470     PyObject * obj0 = 0 ;
8471     char *kwnames[] = {
8472         (char *) "self", NULL
8473     };
8474
8475     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFamily",kwnames,&obj0)) goto fail;
8476     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8477     if (SWIG_arg_fail(1)) SWIG_fail;
8478     {
8479         PyThreadState* __tstate = wxPyBeginAllowThreads();
8480         result = (wxFontFamily)((wxNativeFontInfo const *)arg1)->GetFamily();
8481
8482         wxPyEndAllowThreads(__tstate);
8483         if (PyErr_Occurred()) SWIG_fail;
8484     }
8485     resultobj = SWIG_From_int((result));
8486     return resultobj;
8487     fail:
8488     return NULL;
8489 }
8490
8491
8492 static PyObject *_wrap_NativeFontInfo_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8493     PyObject *resultobj;
8494     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8495     wxFontEncoding result;
8496     PyObject * obj0 = 0 ;
8497     char *kwnames[] = {
8498         (char *) "self", NULL
8499     };
8500
8501     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetEncoding",kwnames,&obj0)) goto fail;
8502     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8503     if (SWIG_arg_fail(1)) SWIG_fail;
8504     {
8505         PyThreadState* __tstate = wxPyBeginAllowThreads();
8506         result = (wxFontEncoding)((wxNativeFontInfo const *)arg1)->GetEncoding();
8507
8508         wxPyEndAllowThreads(__tstate);
8509         if (PyErr_Occurred()) SWIG_fail;
8510     }
8511     resultobj = SWIG_From_int((result));
8512     return resultobj;
8513     fail:
8514     return NULL;
8515 }
8516
8517
8518 static PyObject *_wrap_NativeFontInfo_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
8519     PyObject *resultobj;
8520     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8521     int arg2 ;
8522     PyObject * obj0 = 0 ;
8523     PyObject * obj1 = 0 ;
8524     char *kwnames[] = {
8525         (char *) "self",(char *) "pointsize", NULL
8526     };
8527
8528     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
8529     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8530     if (SWIG_arg_fail(1)) SWIG_fail;
8531     {
8532         arg2 = (int)(SWIG_As_int(obj1));
8533         if (SWIG_arg_fail(2)) SWIG_fail;
8534     }
8535     {
8536         PyThreadState* __tstate = wxPyBeginAllowThreads();
8537         (arg1)->SetPointSize(arg2);
8538
8539         wxPyEndAllowThreads(__tstate);
8540         if (PyErr_Occurred()) SWIG_fail;
8541     }
8542     Py_INCREF(Py_None); resultobj = Py_None;
8543     return resultobj;
8544     fail:
8545     return NULL;
8546 }
8547
8548
8549 static PyObject *_wrap_NativeFontInfo_SetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
8550     PyObject *resultobj;
8551     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8552     wxSize *arg2 = 0 ;
8553     wxSize temp2 ;
8554     PyObject * obj0 = 0 ;
8555     PyObject * obj1 = 0 ;
8556     char *kwnames[] = {
8557         (char *) "self",(char *) "pixelSize", NULL
8558     };
8559
8560     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPixelSize",kwnames,&obj0,&obj1)) goto fail;
8561     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8562     if (SWIG_arg_fail(1)) SWIG_fail;
8563     {
8564         arg2 = &temp2;
8565         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8566     }
8567     {
8568         PyThreadState* __tstate = wxPyBeginAllowThreads();
8569         (arg1)->SetPixelSize((wxSize const &)*arg2);
8570
8571         wxPyEndAllowThreads(__tstate);
8572         if (PyErr_Occurred()) SWIG_fail;
8573     }
8574     Py_INCREF(Py_None); resultobj = Py_None;
8575     return resultobj;
8576     fail:
8577     return NULL;
8578 }
8579
8580
8581 static PyObject *_wrap_NativeFontInfo_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
8582     PyObject *resultobj;
8583     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8584     wxFontStyle arg2 ;
8585     PyObject * obj0 = 0 ;
8586     PyObject * obj1 = 0 ;
8587     char *kwnames[] = {
8588         (char *) "self",(char *) "style", NULL
8589     };
8590
8591     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetStyle",kwnames,&obj0,&obj1)) goto fail;
8592     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8593     if (SWIG_arg_fail(1)) SWIG_fail;
8594     {
8595         arg2 = (wxFontStyle)(SWIG_As_int(obj1));
8596         if (SWIG_arg_fail(2)) SWIG_fail;
8597     }
8598     {
8599         PyThreadState* __tstate = wxPyBeginAllowThreads();
8600         (arg1)->SetStyle((wxFontStyle )arg2);
8601
8602         wxPyEndAllowThreads(__tstate);
8603         if (PyErr_Occurred()) SWIG_fail;
8604     }
8605     Py_INCREF(Py_None); resultobj = Py_None;
8606     return resultobj;
8607     fail:
8608     return NULL;
8609 }
8610
8611
8612 static PyObject *_wrap_NativeFontInfo_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
8613     PyObject *resultobj;
8614     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8615     wxFontWeight arg2 ;
8616     PyObject * obj0 = 0 ;
8617     PyObject * obj1 = 0 ;
8618     char *kwnames[] = {
8619         (char *) "self",(char *) "weight", NULL
8620     };
8621
8622     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetWeight",kwnames,&obj0,&obj1)) goto fail;
8623     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8624     if (SWIG_arg_fail(1)) SWIG_fail;
8625     {
8626         arg2 = (wxFontWeight)(SWIG_As_int(obj1));
8627         if (SWIG_arg_fail(2)) SWIG_fail;
8628     }
8629     {
8630         PyThreadState* __tstate = wxPyBeginAllowThreads();
8631         (arg1)->SetWeight((wxFontWeight )arg2);
8632
8633         wxPyEndAllowThreads(__tstate);
8634         if (PyErr_Occurred()) SWIG_fail;
8635     }
8636     Py_INCREF(Py_None); resultobj = Py_None;
8637     return resultobj;
8638     fail:
8639     return NULL;
8640 }
8641
8642
8643 static PyObject *_wrap_NativeFontInfo_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
8644     PyObject *resultobj;
8645     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8646     bool arg2 ;
8647     PyObject * obj0 = 0 ;
8648     PyObject * obj1 = 0 ;
8649     char *kwnames[] = {
8650         (char *) "self",(char *) "underlined", NULL
8651     };
8652
8653     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
8654     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8655     if (SWIG_arg_fail(1)) SWIG_fail;
8656     {
8657         arg2 = (bool)(SWIG_As_bool(obj1));
8658         if (SWIG_arg_fail(2)) SWIG_fail;
8659     }
8660     {
8661         PyThreadState* __tstate = wxPyBeginAllowThreads();
8662         (arg1)->SetUnderlined(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_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
8675     PyObject *resultobj;
8676     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8677     wxString arg2 ;
8678     PyObject * obj0 = 0 ;
8679     PyObject * obj1 = 0 ;
8680     char *kwnames[] = {
8681         (char *) "self",(char *) "facename", NULL
8682     };
8683
8684     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFaceName",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         wxString* sptr = wxString_in_helper(obj1);
8689         if (sptr == NULL) SWIG_fail;
8690         arg2 = *sptr;
8691         delete sptr;
8692     }
8693     {
8694         PyThreadState* __tstate = wxPyBeginAllowThreads();
8695         (arg1)->SetFaceName(arg2);
8696
8697         wxPyEndAllowThreads(__tstate);
8698         if (PyErr_Occurred()) SWIG_fail;
8699     }
8700     Py_INCREF(Py_None); resultobj = Py_None;
8701     return resultobj;
8702     fail:
8703     return NULL;
8704 }
8705
8706
8707 static PyObject *_wrap_NativeFontInfo_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
8708     PyObject *resultobj;
8709     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8710     wxFontFamily arg2 ;
8711     PyObject * obj0 = 0 ;
8712     PyObject * obj1 = 0 ;
8713     char *kwnames[] = {
8714         (char *) "self",(char *) "family", NULL
8715     };
8716
8717     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFamily",kwnames,&obj0,&obj1)) goto fail;
8718     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8719     if (SWIG_arg_fail(1)) SWIG_fail;
8720     {
8721         arg2 = (wxFontFamily)(SWIG_As_int(obj1));
8722         if (SWIG_arg_fail(2)) SWIG_fail;
8723     }
8724     {
8725         PyThreadState* __tstate = wxPyBeginAllowThreads();
8726         (arg1)->SetFamily((wxFontFamily )arg2);
8727
8728         wxPyEndAllowThreads(__tstate);
8729         if (PyErr_Occurred()) SWIG_fail;
8730     }
8731     Py_INCREF(Py_None); resultobj = Py_None;
8732     return resultobj;
8733     fail:
8734     return NULL;
8735 }
8736
8737
8738 static PyObject *_wrap_NativeFontInfo_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8739     PyObject *resultobj;
8740     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8741     wxFontEncoding arg2 ;
8742     PyObject * obj0 = 0 ;
8743     PyObject * obj1 = 0 ;
8744     char *kwnames[] = {
8745         (char *) "self",(char *) "encoding", NULL
8746     };
8747
8748     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetEncoding",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 = (wxFontEncoding)(SWIG_As_int(obj1));
8753         if (SWIG_arg_fail(2)) SWIG_fail;
8754     }
8755     {
8756         PyThreadState* __tstate = wxPyBeginAllowThreads();
8757         (arg1)->SetEncoding((wxFontEncoding )arg2);
8758
8759         wxPyEndAllowThreads(__tstate);
8760         if (PyErr_Occurred()) SWIG_fail;
8761     }
8762     Py_INCREF(Py_None); resultobj = Py_None;
8763     return resultobj;
8764     fail:
8765     return NULL;
8766 }
8767
8768
8769 static PyObject *_wrap_NativeFontInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8770     PyObject *resultobj;
8771     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8772     wxString *arg2 = 0 ;
8773     bool result;
8774     bool temp2 = false ;
8775     PyObject * obj0 = 0 ;
8776     PyObject * obj1 = 0 ;
8777     char *kwnames[] = {
8778         (char *) "self",(char *) "s", NULL
8779     };
8780
8781     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8782     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8783     if (SWIG_arg_fail(1)) SWIG_fail;
8784     {
8785         arg2 = wxString_in_helper(obj1);
8786         if (arg2 == NULL) SWIG_fail;
8787         temp2 = true;
8788     }
8789     {
8790         PyThreadState* __tstate = wxPyBeginAllowThreads();
8791         result = (bool)(arg1)->FromString((wxString const &)*arg2);
8792
8793         wxPyEndAllowThreads(__tstate);
8794         if (PyErr_Occurred()) SWIG_fail;
8795     }
8796     {
8797         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8798     }
8799     {
8800         if (temp2)
8801         delete arg2;
8802     }
8803     return resultobj;
8804     fail:
8805     {
8806         if (temp2)
8807         delete arg2;
8808     }
8809     return NULL;
8810 }
8811
8812
8813 static PyObject *_wrap_NativeFontInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8814     PyObject *resultobj;
8815     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8816     wxString result;
8817     PyObject * obj0 = 0 ;
8818     char *kwnames[] = {
8819         (char *) "self", NULL
8820     };
8821
8822     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToString",kwnames,&obj0)) goto fail;
8823     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8824     if (SWIG_arg_fail(1)) SWIG_fail;
8825     {
8826         PyThreadState* __tstate = wxPyBeginAllowThreads();
8827         result = ((wxNativeFontInfo const *)arg1)->ToString();
8828
8829         wxPyEndAllowThreads(__tstate);
8830         if (PyErr_Occurred()) SWIG_fail;
8831     }
8832     {
8833 #if wxUSE_UNICODE
8834         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8835 #else
8836         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8837 #endif
8838     }
8839     return resultobj;
8840     fail:
8841     return NULL;
8842 }
8843
8844
8845 static PyObject *_wrap_NativeFontInfo___str__(PyObject *, PyObject *args, PyObject *kwargs) {
8846     PyObject *resultobj;
8847     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8848     wxString result;
8849     PyObject * obj0 = 0 ;
8850     char *kwnames[] = {
8851         (char *) "self", NULL
8852     };
8853
8854     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo___str__",kwnames,&obj0)) goto fail;
8855     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8856     if (SWIG_arg_fail(1)) SWIG_fail;
8857     {
8858         PyThreadState* __tstate = wxPyBeginAllowThreads();
8859         result = wxNativeFontInfo___str__(arg1);
8860
8861         wxPyEndAllowThreads(__tstate);
8862         if (PyErr_Occurred()) SWIG_fail;
8863     }
8864     {
8865 #if wxUSE_UNICODE
8866         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8867 #else
8868         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8869 #endif
8870     }
8871     return resultobj;
8872     fail:
8873     return NULL;
8874 }
8875
8876
8877 static PyObject *_wrap_NativeFontInfo_FromUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8878     PyObject *resultobj;
8879     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8880     wxString *arg2 = 0 ;
8881     bool result;
8882     bool temp2 = false ;
8883     PyObject * obj0 = 0 ;
8884     PyObject * obj1 = 0 ;
8885     char *kwnames[] = {
8886         (char *) "self",(char *) "s", NULL
8887     };
8888
8889     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromUserString",kwnames,&obj0,&obj1)) goto fail;
8890     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8891     if (SWIG_arg_fail(1)) SWIG_fail;
8892     {
8893         arg2 = wxString_in_helper(obj1);
8894         if (arg2 == NULL) SWIG_fail;
8895         temp2 = true;
8896     }
8897     {
8898         PyThreadState* __tstate = wxPyBeginAllowThreads();
8899         result = (bool)(arg1)->FromUserString((wxString const &)*arg2);
8900
8901         wxPyEndAllowThreads(__tstate);
8902         if (PyErr_Occurred()) SWIG_fail;
8903     }
8904     {
8905         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8906     }
8907     {
8908         if (temp2)
8909         delete arg2;
8910     }
8911     return resultobj;
8912     fail:
8913     {
8914         if (temp2)
8915         delete arg2;
8916     }
8917     return NULL;
8918 }
8919
8920
8921 static PyObject *_wrap_NativeFontInfo_ToUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8922     PyObject *resultobj;
8923     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8924     wxString result;
8925     PyObject * obj0 = 0 ;
8926     char *kwnames[] = {
8927         (char *) "self", NULL
8928     };
8929
8930     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToUserString",kwnames,&obj0)) goto fail;
8931     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8932     if (SWIG_arg_fail(1)) SWIG_fail;
8933     {
8934         PyThreadState* __tstate = wxPyBeginAllowThreads();
8935         result = ((wxNativeFontInfo const *)arg1)->ToUserString();
8936
8937         wxPyEndAllowThreads(__tstate);
8938         if (PyErr_Occurred()) SWIG_fail;
8939     }
8940     {
8941 #if wxUSE_UNICODE
8942         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8943 #else
8944         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8945 #endif
8946     }
8947     return resultobj;
8948     fail:
8949     return NULL;
8950 }
8951
8952
8953 static PyObject * NativeFontInfo_swigregister(PyObject *, PyObject *args) {
8954     PyObject *obj;
8955     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8956     SWIG_TypeClientData(SWIGTYPE_p_wxNativeFontInfo, obj);
8957     Py_INCREF(obj);
8958     return Py_BuildValue((char *)"");
8959 }
8960 static PyObject *_wrap_NativeEncodingInfo_facename_set(PyObject *, PyObject *args, PyObject *kwargs) {
8961     PyObject *resultobj;
8962     wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8963     wxString *arg2 = (wxString *) 0 ;
8964     bool temp2 = false ;
8965     PyObject * obj0 = 0 ;
8966     PyObject * obj1 = 0 ;
8967     char *kwnames[] = {
8968         (char *) "self",(char *) "facename", NULL
8969     };
8970
8971     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_facename_set",kwnames,&obj0,&obj1)) goto fail;
8972     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8973     if (SWIG_arg_fail(1)) SWIG_fail;
8974     {
8975         arg2 = wxString_in_helper(obj1);
8976         if (arg2 == NULL) SWIG_fail;
8977         temp2 = true;
8978     }
8979     if (arg1) (arg1)->facename = *arg2;
8980
8981     Py_INCREF(Py_None); resultobj = Py_None;
8982     {
8983         if (temp2)
8984         delete arg2;
8985     }
8986     return resultobj;
8987     fail:
8988     {
8989         if (temp2)
8990         delete arg2;
8991     }
8992     return NULL;
8993 }
8994
8995
8996 static PyObject *_wrap_NativeEncodingInfo_facename_get(PyObject *, PyObject *args, PyObject *kwargs) {
8997     PyObject *resultobj;
8998     wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8999     wxString *result;
9000     PyObject * obj0 = 0 ;
9001     char *kwnames[] = {
9002         (char *) "self", NULL
9003     };
9004
9005     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_facename_get",kwnames,&obj0)) goto fail;
9006     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9007     if (SWIG_arg_fail(1)) SWIG_fail;
9008     result = (wxString *)& ((arg1)->facename);
9009
9010     {
9011 #if wxUSE_UNICODE
9012         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9013 #else
9014         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9015 #endif
9016     }
9017     return resultobj;
9018     fail:
9019     return NULL;
9020 }
9021
9022
9023 static PyObject *_wrap_NativeEncodingInfo_encoding_set(PyObject *, PyObject *args, PyObject *kwargs) {
9024     PyObject *resultobj;
9025     wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9026     wxFontEncoding arg2 ;
9027     PyObject * obj0 = 0 ;
9028     PyObject * obj1 = 0 ;
9029     char *kwnames[] = {
9030         (char *) "self",(char *) "encoding", NULL
9031     };
9032
9033     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_encoding_set",kwnames,&obj0,&obj1)) goto fail;
9034     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9035     if (SWIG_arg_fail(1)) SWIG_fail;
9036     {
9037         arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9038         if (SWIG_arg_fail(2)) SWIG_fail;
9039     }
9040     if (arg1) (arg1)->encoding = (wxFontEncoding )arg2;
9041
9042     Py_INCREF(Py_None); resultobj = Py_None;
9043     return resultobj;
9044     fail:
9045     return NULL;
9046 }
9047
9048
9049 static PyObject *_wrap_NativeEncodingInfo_encoding_get(PyObject *, PyObject *args, PyObject *kwargs) {
9050     PyObject *resultobj;
9051     wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9052     wxFontEncoding result;
9053     PyObject * obj0 = 0 ;
9054     char *kwnames[] = {
9055         (char *) "self", NULL
9056     };
9057
9058     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_encoding_get",kwnames,&obj0)) goto fail;
9059     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9060     if (SWIG_arg_fail(1)) SWIG_fail;
9061     result = (wxFontEncoding) ((arg1)->encoding);
9062
9063     resultobj = SWIG_From_int((result));
9064     return resultobj;
9065     fail:
9066     return NULL;
9067 }
9068
9069
9070 static PyObject *_wrap_new_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9071     PyObject *resultobj;
9072     wxNativeEncodingInfo *result;
9073     char *kwnames[] = {
9074         NULL
9075     };
9076
9077     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeEncodingInfo",kwnames)) goto fail;
9078     {
9079         PyThreadState* __tstate = wxPyBeginAllowThreads();
9080         result = (wxNativeEncodingInfo *)new wxNativeEncodingInfo();
9081
9082         wxPyEndAllowThreads(__tstate);
9083         if (PyErr_Occurred()) SWIG_fail;
9084     }
9085     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 1);
9086     return resultobj;
9087     fail:
9088     return NULL;
9089 }
9090
9091
9092 static PyObject *_wrap_delete_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9093     PyObject *resultobj;
9094     wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9095     PyObject * obj0 = 0 ;
9096     char *kwnames[] = {
9097         (char *) "self", NULL
9098     };
9099
9100     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeEncodingInfo",kwnames,&obj0)) goto fail;
9101     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9102     if (SWIG_arg_fail(1)) SWIG_fail;
9103     {
9104         PyThreadState* __tstate = wxPyBeginAllowThreads();
9105         delete arg1;
9106
9107         wxPyEndAllowThreads(__tstate);
9108         if (PyErr_Occurred()) SWIG_fail;
9109     }
9110     Py_INCREF(Py_None); resultobj = Py_None;
9111     return resultobj;
9112     fail:
9113     return NULL;
9114 }
9115
9116
9117 static PyObject *_wrap_NativeEncodingInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
9118     PyObject *resultobj;
9119     wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9120     wxString *arg2 = 0 ;
9121     bool result;
9122     bool temp2 = false ;
9123     PyObject * obj0 = 0 ;
9124     PyObject * obj1 = 0 ;
9125     char *kwnames[] = {
9126         (char *) "self",(char *) "s", NULL
9127     };
9128
9129     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
9130     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9131     if (SWIG_arg_fail(1)) SWIG_fail;
9132     {
9133         arg2 = wxString_in_helper(obj1);
9134         if (arg2 == NULL) SWIG_fail;
9135         temp2 = true;
9136     }
9137     {
9138         PyThreadState* __tstate = wxPyBeginAllowThreads();
9139         result = (bool)(arg1)->FromString((wxString const &)*arg2);
9140
9141         wxPyEndAllowThreads(__tstate);
9142         if (PyErr_Occurred()) SWIG_fail;
9143     }
9144     {
9145         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9146     }
9147     {
9148         if (temp2)
9149         delete arg2;
9150     }
9151     return resultobj;
9152     fail:
9153     {
9154         if (temp2)
9155         delete arg2;
9156     }
9157     return NULL;
9158 }
9159
9160
9161 static PyObject *_wrap_NativeEncodingInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
9162     PyObject *resultobj;
9163     wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9164     wxString result;
9165     PyObject * obj0 = 0 ;
9166     char *kwnames[] = {
9167         (char *) "self", NULL
9168     };
9169
9170     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_ToString",kwnames,&obj0)) goto fail;
9171     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9172     if (SWIG_arg_fail(1)) SWIG_fail;
9173     {
9174         PyThreadState* __tstate = wxPyBeginAllowThreads();
9175         result = ((wxNativeEncodingInfo const *)arg1)->ToString();
9176
9177         wxPyEndAllowThreads(__tstate);
9178         if (PyErr_Occurred()) SWIG_fail;
9179     }
9180     {
9181 #if wxUSE_UNICODE
9182         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9183 #else
9184         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9185 #endif
9186     }
9187     return resultobj;
9188     fail:
9189     return NULL;
9190 }
9191
9192
9193 static PyObject * NativeEncodingInfo_swigregister(PyObject *, PyObject *args) {
9194     PyObject *obj;
9195     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9196     SWIG_TypeClientData(SWIGTYPE_p_wxNativeEncodingInfo, obj);
9197     Py_INCREF(obj);
9198     return Py_BuildValue((char *)"");
9199 }
9200 static PyObject *_wrap_GetNativeFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9201     PyObject *resultobj;
9202     wxFontEncoding arg1 ;
9203     wxNativeEncodingInfo *result;
9204     PyObject * obj0 = 0 ;
9205     char *kwnames[] = {
9206         (char *) "encoding", NULL
9207     };
9208
9209     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetNativeFontEncoding",kwnames,&obj0)) goto fail;
9210     {
9211         arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
9212         if (SWIG_arg_fail(1)) SWIG_fail;
9213     }
9214     {
9215         PyThreadState* __tstate = wxPyBeginAllowThreads();
9216         result = (wxNativeEncodingInfo *)wxGetNativeFontEncoding((wxFontEncoding )arg1);
9217
9218         wxPyEndAllowThreads(__tstate);
9219         if (PyErr_Occurred()) SWIG_fail;
9220     }
9221     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 0);
9222     return resultobj;
9223     fail:
9224     return NULL;
9225 }
9226
9227
9228 static PyObject *_wrap_TestFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9229     PyObject *resultobj;
9230     wxNativeEncodingInfo *arg1 = 0 ;
9231     bool result;
9232     PyObject * obj0 = 0 ;
9233     char *kwnames[] = {
9234         (char *) "info", NULL
9235     };
9236
9237     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TestFontEncoding",kwnames,&obj0)) goto fail;
9238     {
9239         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9240         if (SWIG_arg_fail(1)) SWIG_fail;
9241         if (arg1 == NULL) {
9242             SWIG_null_ref("wxNativeEncodingInfo");
9243         }
9244         if (SWIG_arg_fail(1)) SWIG_fail;
9245     }
9246     {
9247         PyThreadState* __tstate = wxPyBeginAllowThreads();
9248         result = (bool)wxTestFontEncoding((wxNativeEncodingInfo const &)*arg1);
9249
9250         wxPyEndAllowThreads(__tstate);
9251         if (PyErr_Occurred()) SWIG_fail;
9252     }
9253     {
9254         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9255     }
9256     return resultobj;
9257     fail:
9258     return NULL;
9259 }
9260
9261
9262 static PyObject *_wrap_new_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
9263     PyObject *resultobj;
9264     wxFontMapper *result;
9265     char *kwnames[] = {
9266         NULL
9267     };
9268
9269     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontMapper",kwnames)) goto fail;
9270     {
9271         PyThreadState* __tstate = wxPyBeginAllowThreads();
9272         result = (wxFontMapper *)new wxFontMapper();
9273
9274         wxPyEndAllowThreads(__tstate);
9275         if (PyErr_Occurred()) SWIG_fail;
9276     }
9277     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 1);
9278     return resultobj;
9279     fail:
9280     return NULL;
9281 }
9282
9283
9284 static PyObject *_wrap_delete_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
9285     PyObject *resultobj;
9286     wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9287     PyObject * obj0 = 0 ;
9288     char *kwnames[] = {
9289         (char *) "self", NULL
9290     };
9291
9292     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontMapper",kwnames,&obj0)) goto fail;
9293     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9294     if (SWIG_arg_fail(1)) SWIG_fail;
9295     {
9296         PyThreadState* __tstate = wxPyBeginAllowThreads();
9297         delete arg1;
9298
9299         wxPyEndAllowThreads(__tstate);
9300         if (PyErr_Occurred()) SWIG_fail;
9301     }
9302     Py_INCREF(Py_None); resultobj = Py_None;
9303     return resultobj;
9304     fail:
9305     return NULL;
9306 }
9307
9308
9309 static PyObject *_wrap_FontMapper_Get(PyObject *, PyObject *args, PyObject *kwargs) {
9310     PyObject *resultobj;
9311     wxFontMapper *result;
9312     char *kwnames[] = {
9313         NULL
9314     };
9315
9316     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_Get",kwnames)) goto fail;
9317     {
9318         PyThreadState* __tstate = wxPyBeginAllowThreads();
9319         result = (wxFontMapper *)wxFontMapper::Get();
9320
9321         wxPyEndAllowThreads(__tstate);
9322         if (PyErr_Occurred()) SWIG_fail;
9323     }
9324     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
9325     return resultobj;
9326     fail:
9327     return NULL;
9328 }
9329
9330
9331 static PyObject *_wrap_FontMapper_Set(PyObject *, PyObject *args, PyObject *kwargs) {
9332     PyObject *resultobj;
9333     wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9334     wxFontMapper *result;
9335     PyObject * obj0 = 0 ;
9336     char *kwnames[] = {
9337         (char *) "mapper", NULL
9338     };
9339
9340     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_Set",kwnames,&obj0)) goto fail;
9341     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9342     if (SWIG_arg_fail(1)) SWIG_fail;
9343     {
9344         PyThreadState* __tstate = wxPyBeginAllowThreads();
9345         result = (wxFontMapper *)wxFontMapper::Set(arg1);
9346
9347         wxPyEndAllowThreads(__tstate);
9348         if (PyErr_Occurred()) SWIG_fail;
9349     }
9350     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
9351     return resultobj;
9352     fail:
9353     return NULL;
9354 }
9355
9356
9357 static PyObject *_wrap_FontMapper_CharsetToEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9358     PyObject *resultobj;
9359     wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9360     wxString *arg2 = 0 ;
9361     bool arg3 = (bool) true ;
9362     wxFontEncoding result;
9363     bool temp2 = false ;
9364     PyObject * obj0 = 0 ;
9365     PyObject * obj1 = 0 ;
9366     PyObject * obj2 = 0 ;
9367     char *kwnames[] = {
9368         (char *) "self",(char *) "charset",(char *) "interactive", NULL
9369     };
9370
9371     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_CharsetToEncoding",kwnames,&obj0,&obj1,&obj2)) goto fail;
9372     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9373     if (SWIG_arg_fail(1)) SWIG_fail;
9374     {
9375         arg2 = wxString_in_helper(obj1);
9376         if (arg2 == NULL) SWIG_fail;
9377         temp2 = true;
9378     }
9379     if (obj2) {
9380         {
9381             arg3 = (bool)(SWIG_As_bool(obj2));
9382             if (SWIG_arg_fail(3)) SWIG_fail;
9383         }
9384     }
9385     {
9386         PyThreadState* __tstate = wxPyBeginAllowThreads();
9387         result = (wxFontEncoding)(arg1)->CharsetToEncoding((wxString const &)*arg2,arg3);
9388
9389         wxPyEndAllowThreads(__tstate);
9390         if (PyErr_Occurred()) SWIG_fail;
9391     }
9392     resultobj = SWIG_From_int((result));
9393     {
9394         if (temp2)
9395         delete arg2;
9396     }
9397     return resultobj;
9398     fail:
9399     {
9400         if (temp2)
9401         delete arg2;
9402     }
9403     return NULL;
9404 }
9405
9406
9407 static PyObject *_wrap_FontMapper_GetSupportedEncodingsCount(PyObject *, PyObject *args, PyObject *kwargs) {
9408     PyObject *resultobj;
9409     size_t result;
9410     char *kwnames[] = {
9411         NULL
9412     };
9413
9414     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetSupportedEncodingsCount",kwnames)) goto fail;
9415     {
9416         PyThreadState* __tstate = wxPyBeginAllowThreads();
9417         result = (size_t)wxFontMapper::GetSupportedEncodingsCount();
9418
9419         wxPyEndAllowThreads(__tstate);
9420         if (PyErr_Occurred()) SWIG_fail;
9421     }
9422     {
9423         resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9424     }
9425     return resultobj;
9426     fail:
9427     return NULL;
9428 }
9429
9430
9431 static PyObject *_wrap_FontMapper_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9432     PyObject *resultobj;
9433     size_t arg1 ;
9434     wxFontEncoding result;
9435     PyObject * obj0 = 0 ;
9436     char *kwnames[] = {
9437         (char *) "n", NULL
9438     };
9439
9440     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncoding",kwnames,&obj0)) goto fail;
9441     {
9442         arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
9443         if (SWIG_arg_fail(1)) SWIG_fail;
9444     }
9445     {
9446         PyThreadState* __tstate = wxPyBeginAllowThreads();
9447         result = (wxFontEncoding)wxFontMapper::GetEncoding(arg1);
9448
9449         wxPyEndAllowThreads(__tstate);
9450         if (PyErr_Occurred()) SWIG_fail;
9451     }
9452     resultobj = SWIG_From_int((result));
9453     return resultobj;
9454     fail:
9455     return NULL;
9456 }
9457
9458
9459 static PyObject *_wrap_FontMapper_GetEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
9460     PyObject *resultobj;
9461     wxFontEncoding arg1 ;
9462     wxString result;
9463     PyObject * obj0 = 0 ;
9464     char *kwnames[] = {
9465         (char *) "encoding", NULL
9466     };
9467
9468     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingName",kwnames,&obj0)) goto fail;
9469     {
9470         arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
9471         if (SWIG_arg_fail(1)) SWIG_fail;
9472     }
9473     {
9474         PyThreadState* __tstate = wxPyBeginAllowThreads();
9475         result = wxFontMapper::GetEncodingName((wxFontEncoding )arg1);
9476
9477         wxPyEndAllowThreads(__tstate);
9478         if (PyErr_Occurred()) SWIG_fail;
9479     }
9480     {
9481 #if wxUSE_UNICODE
9482         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9483 #else
9484         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9485 #endif
9486     }
9487     return resultobj;
9488     fail:
9489     return NULL;
9490 }
9491
9492
9493 static PyObject *_wrap_FontMapper_GetEncodingDescription(PyObject *, PyObject *args, PyObject *kwargs) {
9494     PyObject *resultobj;
9495     wxFontEncoding arg1 ;
9496     wxString result;
9497     PyObject * obj0 = 0 ;
9498     char *kwnames[] = {
9499         (char *) "encoding", NULL
9500     };
9501
9502     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingDescription",kwnames,&obj0)) goto fail;
9503     {
9504         arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
9505         if (SWIG_arg_fail(1)) SWIG_fail;
9506     }
9507     {
9508         PyThreadState* __tstate = wxPyBeginAllowThreads();
9509         result = wxFontMapper::GetEncodingDescription((wxFontEncoding )arg1);
9510
9511         wxPyEndAllowThreads(__tstate);
9512         if (PyErr_Occurred()) SWIG_fail;
9513     }
9514     {
9515 #if wxUSE_UNICODE
9516         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9517 #else
9518         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9519 #endif
9520     }
9521     return resultobj;
9522     fail:
9523     return NULL;
9524 }
9525
9526
9527 static PyObject *_wrap_FontMapper_GetEncodingFromName(PyObject *, PyObject *args, PyObject *kwargs) {
9528     PyObject *resultobj;
9529     wxString *arg1 = 0 ;
9530     wxFontEncoding result;
9531     bool temp1 = false ;
9532     PyObject * obj0 = 0 ;
9533     char *kwnames[] = {
9534         (char *) "name", NULL
9535     };
9536
9537     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingFromName",kwnames,&obj0)) goto fail;
9538     {
9539         arg1 = wxString_in_helper(obj0);
9540         if (arg1 == NULL) SWIG_fail;
9541         temp1 = true;
9542     }
9543     {
9544         PyThreadState* __tstate = wxPyBeginAllowThreads();
9545         result = (wxFontEncoding)wxFontMapper::GetEncodingFromName((wxString const &)*arg1);
9546
9547         wxPyEndAllowThreads(__tstate);
9548         if (PyErr_Occurred()) SWIG_fail;
9549     }
9550     resultobj = SWIG_From_int((result));
9551     {
9552         if (temp1)
9553         delete arg1;
9554     }
9555     return resultobj;
9556     fail:
9557     {
9558         if (temp1)
9559         delete arg1;
9560     }
9561     return NULL;
9562 }
9563
9564
9565 static PyObject *_wrap_FontMapper_SetConfig(PyObject *, PyObject *args, PyObject *kwargs) {
9566     PyObject *resultobj;
9567     wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9568     wxConfigBase *arg2 = (wxConfigBase *) 0 ;
9569     PyObject * obj0 = 0 ;
9570     PyObject * obj1 = 0 ;
9571     char *kwnames[] = {
9572         (char *) "self",(char *) "config", NULL
9573     };
9574
9575     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfig",kwnames,&obj0,&obj1)) goto fail;
9576     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9577     if (SWIG_arg_fail(1)) SWIG_fail;
9578     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
9579     if (SWIG_arg_fail(2)) SWIG_fail;
9580     {
9581         PyThreadState* __tstate = wxPyBeginAllowThreads();
9582         (arg1)->SetConfig(arg2);
9583
9584         wxPyEndAllowThreads(__tstate);
9585         if (PyErr_Occurred()) SWIG_fail;
9586     }
9587     Py_INCREF(Py_None); resultobj = Py_None;
9588     return resultobj;
9589     fail:
9590     return NULL;
9591 }
9592
9593
9594 static PyObject *_wrap_FontMapper_SetConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
9595     PyObject *resultobj;
9596     wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9597     wxString *arg2 = 0 ;
9598     bool temp2 = false ;
9599     PyObject * obj0 = 0 ;
9600     PyObject * obj1 = 0 ;
9601     char *kwnames[] = {
9602         (char *) "self",(char *) "prefix", NULL
9603     };
9604
9605     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfigPath",kwnames,&obj0,&obj1)) goto fail;
9606     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9607     if (SWIG_arg_fail(1)) SWIG_fail;
9608     {
9609         arg2 = wxString_in_helper(obj1);
9610         if (arg2 == NULL) SWIG_fail;
9611         temp2 = true;
9612     }
9613     {
9614         PyThreadState* __tstate = wxPyBeginAllowThreads();
9615         (arg1)->SetConfigPath((wxString const &)*arg2);
9616
9617         wxPyEndAllowThreads(__tstate);
9618         if (PyErr_Occurred()) SWIG_fail;
9619     }
9620     Py_INCREF(Py_None); resultobj = Py_None;
9621     {
9622         if (temp2)
9623         delete arg2;
9624     }
9625     return resultobj;
9626     fail:
9627     {
9628         if (temp2)
9629         delete arg2;
9630     }
9631     return NULL;
9632 }
9633
9634
9635 static PyObject *_wrap_FontMapper_GetDefaultConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
9636     PyObject *resultobj;
9637     wxString result;
9638     char *kwnames[] = {
9639         NULL
9640     };
9641
9642     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetDefaultConfigPath",kwnames)) goto fail;
9643     {
9644         PyThreadState* __tstate = wxPyBeginAllowThreads();
9645         result = wxFontMapper::GetDefaultConfigPath();
9646
9647         wxPyEndAllowThreads(__tstate);
9648         if (PyErr_Occurred()) SWIG_fail;
9649     }
9650     {
9651 #if wxUSE_UNICODE
9652         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9653 #else
9654         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9655 #endif
9656     }
9657     return resultobj;
9658     fail:
9659     return NULL;
9660 }
9661
9662
9663 static PyObject *_wrap_FontMapper_GetAltForEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9664     PyObject *resultobj;
9665     wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9666     wxFontEncoding arg2 ;
9667     wxString const &arg3_defvalue = wxPyEmptyString ;
9668     wxString *arg3 = (wxString *) &arg3_defvalue ;
9669     bool arg4 = (bool) true ;
9670     PyObject *result;
9671     bool temp3 = false ;
9672     PyObject * obj0 = 0 ;
9673     PyObject * obj1 = 0 ;
9674     PyObject * obj2 = 0 ;
9675     PyObject * obj3 = 0 ;
9676     char *kwnames[] = {
9677         (char *) "self",(char *) "encoding",(char *) "facename",(char *) "interactive", NULL
9678     };
9679
9680     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:FontMapper_GetAltForEncoding",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9681     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9682     if (SWIG_arg_fail(1)) SWIG_fail;
9683     {
9684         arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9685         if (SWIG_arg_fail(2)) SWIG_fail;
9686     }
9687     if (obj2) {
9688         {
9689             arg3 = wxString_in_helper(obj2);
9690             if (arg3 == NULL) SWIG_fail;
9691             temp3 = true;
9692         }
9693     }
9694     if (obj3) {
9695         {
9696             arg4 = (bool)(SWIG_As_bool(obj3));
9697             if (SWIG_arg_fail(4)) SWIG_fail;
9698         }
9699     }
9700     {
9701         PyThreadState* __tstate = wxPyBeginAllowThreads();
9702         result = (PyObject *)wxFontMapper_GetAltForEncoding(arg1,(wxFontEncoding )arg2,(wxString const &)*arg3,arg4);
9703
9704         wxPyEndAllowThreads(__tstate);
9705         if (PyErr_Occurred()) SWIG_fail;
9706     }
9707     resultobj = result;
9708     {
9709         if (temp3)
9710         delete arg3;
9711     }
9712     return resultobj;
9713     fail:
9714     {
9715         if (temp3)
9716         delete arg3;
9717     }
9718     return NULL;
9719 }
9720
9721
9722 static PyObject *_wrap_FontMapper_IsEncodingAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
9723     PyObject *resultobj;
9724     wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9725     wxFontEncoding arg2 ;
9726     wxString const &arg3_defvalue = wxPyEmptyString ;
9727     wxString *arg3 = (wxString *) &arg3_defvalue ;
9728     bool result;
9729     bool temp3 = false ;
9730     PyObject * obj0 = 0 ;
9731     PyObject * obj1 = 0 ;
9732     PyObject * obj2 = 0 ;
9733     char *kwnames[] = {
9734         (char *) "self",(char *) "encoding",(char *) "facename", NULL
9735     };
9736
9737     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_IsEncodingAvailable",kwnames,&obj0,&obj1,&obj2)) goto fail;
9738     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9739     if (SWIG_arg_fail(1)) SWIG_fail;
9740     {
9741         arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9742         if (SWIG_arg_fail(2)) SWIG_fail;
9743     }
9744     if (obj2) {
9745         {
9746             arg3 = wxString_in_helper(obj2);
9747             if (arg3 == NULL) SWIG_fail;
9748             temp3 = true;
9749         }
9750     }
9751     {
9752         PyThreadState* __tstate = wxPyBeginAllowThreads();
9753         result = (bool)(arg1)->IsEncodingAvailable((wxFontEncoding )arg2,(wxString const &)*arg3);
9754
9755         wxPyEndAllowThreads(__tstate);
9756         if (PyErr_Occurred()) SWIG_fail;
9757     }
9758     {
9759         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9760     }
9761     {
9762         if (temp3)
9763         delete arg3;
9764     }
9765     return resultobj;
9766     fail:
9767     {
9768         if (temp3)
9769         delete arg3;
9770     }
9771     return NULL;
9772 }
9773
9774
9775 static PyObject *_wrap_FontMapper_SetDialogParent(PyObject *, PyObject *args, PyObject *kwargs) {
9776     PyObject *resultobj;
9777     wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9778     wxWindow *arg2 = (wxWindow *) 0 ;
9779     PyObject * obj0 = 0 ;
9780     PyObject * obj1 = 0 ;
9781     char *kwnames[] = {
9782         (char *) "self",(char *) "parent", NULL
9783     };
9784
9785     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogParent",kwnames,&obj0,&obj1)) goto fail;
9786     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9787     if (SWIG_arg_fail(1)) SWIG_fail;
9788     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9789     if (SWIG_arg_fail(2)) SWIG_fail;
9790     {
9791         PyThreadState* __tstate = wxPyBeginAllowThreads();
9792         (arg1)->SetDialogParent(arg2);
9793
9794         wxPyEndAllowThreads(__tstate);
9795         if (PyErr_Occurred()) SWIG_fail;
9796     }
9797     Py_INCREF(Py_None); resultobj = Py_None;
9798     return resultobj;
9799     fail:
9800     return NULL;
9801 }
9802
9803
9804 static PyObject *_wrap_FontMapper_SetDialogTitle(PyObject *, PyObject *args, PyObject *kwargs) {
9805     PyObject *resultobj;
9806     wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9807     wxString *arg2 = 0 ;
9808     bool temp2 = false ;
9809     PyObject * obj0 = 0 ;
9810     PyObject * obj1 = 0 ;
9811     char *kwnames[] = {
9812         (char *) "self",(char *) "title", NULL
9813     };
9814
9815     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogTitle",kwnames,&obj0,&obj1)) goto fail;
9816     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9817     if (SWIG_arg_fail(1)) SWIG_fail;
9818     {
9819         arg2 = wxString_in_helper(obj1);
9820         if (arg2 == NULL) SWIG_fail;
9821         temp2 = true;
9822     }
9823     {
9824         PyThreadState* __tstate = wxPyBeginAllowThreads();
9825         (arg1)->SetDialogTitle((wxString const &)*arg2);
9826
9827         wxPyEndAllowThreads(__tstate);
9828         if (PyErr_Occurred()) SWIG_fail;
9829     }
9830     Py_INCREF(Py_None); resultobj = Py_None;
9831     {
9832         if (temp2)
9833         delete arg2;
9834     }
9835     return resultobj;
9836     fail:
9837     {
9838         if (temp2)
9839         delete arg2;
9840     }
9841     return NULL;
9842 }
9843
9844
9845 static PyObject * FontMapper_swigregister(PyObject *, PyObject *args) {
9846     PyObject *obj;
9847     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9848     SWIG_TypeClientData(SWIGTYPE_p_wxFontMapper, obj);
9849     Py_INCREF(obj);
9850     return Py_BuildValue((char *)"");
9851 }
9852 static PyObject *_wrap_new_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9853     PyObject *resultobj;
9854     int arg1 ;
9855     int arg2 ;
9856     int arg3 ;
9857     int arg4 ;
9858     bool arg5 = (bool) false ;
9859     wxString const &arg6_defvalue = wxPyEmptyString ;
9860     wxString *arg6 = (wxString *) &arg6_defvalue ;
9861     wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9862     wxFont *result;
9863     bool temp6 = false ;
9864     PyObject * obj0 = 0 ;
9865     PyObject * obj1 = 0 ;
9866     PyObject * obj2 = 0 ;
9867     PyObject * obj3 = 0 ;
9868     PyObject * obj4 = 0 ;
9869     PyObject * obj5 = 0 ;
9870     PyObject * obj6 = 0 ;
9871     char *kwnames[] = {
9872         (char *) "pointSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "face",(char *) "encoding", NULL
9873     };
9874
9875     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_Font",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9876     {
9877         arg1 = (int)(SWIG_As_int(obj0));
9878         if (SWIG_arg_fail(1)) SWIG_fail;
9879     }
9880     {
9881         arg2 = (int)(SWIG_As_int(obj1));
9882         if (SWIG_arg_fail(2)) SWIG_fail;
9883     }
9884     {
9885         arg3 = (int)(SWIG_As_int(obj2));
9886         if (SWIG_arg_fail(3)) SWIG_fail;
9887     }
9888     {
9889         arg4 = (int)(SWIG_As_int(obj3));
9890         if (SWIG_arg_fail(4)) SWIG_fail;
9891     }
9892     if (obj4) {
9893         {
9894             arg5 = (bool)(SWIG_As_bool(obj4));
9895             if (SWIG_arg_fail(5)) SWIG_fail;
9896         }
9897     }
9898     if (obj5) {
9899         {
9900             arg6 = wxString_in_helper(obj5);
9901             if (arg6 == NULL) SWIG_fail;
9902             temp6 = true;
9903         }
9904     }
9905     if (obj6) {
9906         {
9907             arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9908             if (SWIG_arg_fail(7)) SWIG_fail;
9909         }
9910     }
9911     {
9912         if (!wxPyCheckForApp()) SWIG_fail;
9913         PyThreadState* __tstate = wxPyBeginAllowThreads();
9914         result = (wxFont *)new wxFont(arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9915
9916         wxPyEndAllowThreads(__tstate);
9917         if (PyErr_Occurred()) SWIG_fail;
9918     }
9919     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9920     {
9921         if (temp6)
9922         delete arg6;
9923     }
9924     return resultobj;
9925     fail:
9926     {
9927         if (temp6)
9928         delete arg6;
9929     }
9930     return NULL;
9931 }
9932
9933
9934 static PyObject *_wrap_delete_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9935     PyObject *resultobj;
9936     wxFont *arg1 = (wxFont *) 0 ;
9937     PyObject * obj0 = 0 ;
9938     char *kwnames[] = {
9939         (char *) "self", NULL
9940     };
9941
9942     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Font",kwnames,&obj0)) goto fail;
9943     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9944     if (SWIG_arg_fail(1)) SWIG_fail;
9945     {
9946         PyThreadState* __tstate = wxPyBeginAllowThreads();
9947         delete arg1;
9948
9949         wxPyEndAllowThreads(__tstate);
9950         if (PyErr_Occurred()) SWIG_fail;
9951     }
9952     Py_INCREF(Py_None); resultobj = Py_None;
9953     return resultobj;
9954     fail:
9955     return NULL;
9956 }
9957
9958
9959 static PyObject *_wrap_new_FontFromNativeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9960     PyObject *resultobj;
9961     wxNativeFontInfo *arg1 = 0 ;
9962     wxFont *result;
9963     PyObject * obj0 = 0 ;
9964     char *kwnames[] = {
9965         (char *) "info", NULL
9966     };
9967
9968     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfo",kwnames,&obj0)) goto fail;
9969     {
9970         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
9971         if (SWIG_arg_fail(1)) SWIG_fail;
9972         if (arg1 == NULL) {
9973             SWIG_null_ref("wxNativeFontInfo");
9974         }
9975         if (SWIG_arg_fail(1)) SWIG_fail;
9976     }
9977     {
9978         if (!wxPyCheckForApp()) SWIG_fail;
9979         PyThreadState* __tstate = wxPyBeginAllowThreads();
9980         result = (wxFont *)new wxFont((wxNativeFontInfo const &)*arg1);
9981
9982         wxPyEndAllowThreads(__tstate);
9983         if (PyErr_Occurred()) SWIG_fail;
9984     }
9985     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9986     return resultobj;
9987     fail:
9988     return NULL;
9989 }
9990
9991
9992 static PyObject *_wrap_new_FontFromNativeInfoString(PyObject *, PyObject *args, PyObject *kwargs) {
9993     PyObject *resultobj;
9994     wxString *arg1 = 0 ;
9995     wxFont *result;
9996     bool temp1 = false ;
9997     PyObject * obj0 = 0 ;
9998     char *kwnames[] = {
9999         (char *) "info", NULL
10000     };
10001
10002     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfoString",kwnames,&obj0)) goto fail;
10003     {
10004         arg1 = wxString_in_helper(obj0);
10005         if (arg1 == NULL) SWIG_fail;
10006         temp1 = true;
10007     }
10008     {
10009         if (!wxPyCheckForApp()) SWIG_fail;
10010         PyThreadState* __tstate = wxPyBeginAllowThreads();
10011         result = (wxFont *)new_wxFont((wxString const &)*arg1);
10012
10013         wxPyEndAllowThreads(__tstate);
10014         if (PyErr_Occurred()) SWIG_fail;
10015     }
10016     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
10017     {
10018         if (temp1)
10019         delete arg1;
10020     }
10021     return resultobj;
10022     fail:
10023     {
10024         if (temp1)
10025         delete arg1;
10026     }
10027     return NULL;
10028 }
10029
10030
10031 static PyObject *_wrap_new_Font2(PyObject *, PyObject *args, PyObject *kwargs) {
10032     PyObject *resultobj;
10033     int arg1 ;
10034     wxFontFamily arg2 ;
10035     int arg3 = (int) wxFONTFLAG_DEFAULT ;
10036     wxString const &arg4_defvalue = wxPyEmptyString ;
10037     wxString *arg4 = (wxString *) &arg4_defvalue ;
10038     wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
10039     wxFont *result;
10040     bool temp4 = false ;
10041     PyObject * obj0 = 0 ;
10042     PyObject * obj1 = 0 ;
10043     PyObject * obj2 = 0 ;
10044     PyObject * obj3 = 0 ;
10045     PyObject * obj4 = 0 ;
10046     char *kwnames[] = {
10047         (char *) "pointSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
10048     };
10049
10050     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_Font2",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
10051     {
10052         arg1 = (int)(SWIG_As_int(obj0));
10053         if (SWIG_arg_fail(1)) SWIG_fail;
10054     }
10055     {
10056         arg2 = (wxFontFamily)(SWIG_As_int(obj1));
10057         if (SWIG_arg_fail(2)) SWIG_fail;
10058     }
10059     if (obj2) {
10060         {
10061             arg3 = (int)(SWIG_As_int(obj2));
10062             if (SWIG_arg_fail(3)) SWIG_fail;
10063         }
10064     }
10065     if (obj3) {
10066         {
10067             arg4 = wxString_in_helper(obj3);
10068             if (arg4 == NULL) SWIG_fail;
10069             temp4 = true;
10070         }
10071     }
10072     if (obj4) {
10073         {
10074             arg5 = (wxFontEncoding)(SWIG_As_int(obj4));
10075             if (SWIG_arg_fail(5)) SWIG_fail;
10076         }
10077     }
10078     {
10079         if (!wxPyCheckForApp()) SWIG_fail;
10080         PyThreadState* __tstate = wxPyBeginAllowThreads();
10081         result = (wxFont *)new_wxFont(arg1,(wxFontFamily )arg2,arg3,(wxString const &)*arg4,(wxFontEncoding )arg5);
10082
10083         wxPyEndAllowThreads(__tstate);
10084         if (PyErr_Occurred()) SWIG_fail;
10085     }
10086     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
10087     {
10088         if (temp4)
10089         delete arg4;
10090     }
10091     return resultobj;
10092     fail:
10093     {
10094         if (temp4)
10095         delete arg4;
10096     }
10097     return NULL;
10098 }
10099
10100
10101 static PyObject *_wrap_new_FontFromPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10102     PyObject *resultobj;
10103     wxSize *arg1 = 0 ;
10104     int arg2 ;
10105     int arg3 ;
10106     int arg4 ;
10107     bool arg5 = (bool) false ;
10108     wxString const &arg6_defvalue = wxEmptyString ;
10109     wxString *arg6 = (wxString *) &arg6_defvalue ;
10110     wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
10111     wxFont *result;
10112     wxSize temp1 ;
10113     bool temp6 = false ;
10114     PyObject * obj0 = 0 ;
10115     PyObject * obj1 = 0 ;
10116     PyObject * obj2 = 0 ;
10117     PyObject * obj3 = 0 ;
10118     PyObject * obj4 = 0 ;
10119     PyObject * obj5 = 0 ;
10120     PyObject * obj6 = 0 ;
10121     char *kwnames[] = {
10122         (char *) "pixelSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underlined",(char *) "face",(char *) "encoding", NULL
10123     };
10124
10125     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_FontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
10126     {
10127         arg1 = &temp1;
10128         if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
10129     }
10130     {
10131         arg2 = (int)(SWIG_As_int(obj1));
10132         if (SWIG_arg_fail(2)) SWIG_fail;
10133     }
10134     {
10135         arg3 = (int)(SWIG_As_int(obj2));
10136         if (SWIG_arg_fail(3)) SWIG_fail;
10137     }
10138     {
10139         arg4 = (int)(SWIG_As_int(obj3));
10140         if (SWIG_arg_fail(4)) SWIG_fail;
10141     }
10142     if (obj4) {
10143         {
10144             arg5 = (bool)(SWIG_As_bool(obj4));
10145             if (SWIG_arg_fail(5)) SWIG_fail;
10146         }
10147     }
10148     if (obj5) {
10149         {
10150             arg6 = wxString_in_helper(obj5);
10151             if (arg6 == NULL) SWIG_fail;
10152             temp6 = true;
10153         }
10154     }
10155     if (obj6) {
10156         {
10157             arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
10158             if (SWIG_arg_fail(7)) SWIG_fail;
10159         }
10160     }
10161     {
10162         if (!wxPyCheckForApp()) SWIG_fail;
10163         PyThreadState* __tstate = wxPyBeginAllowThreads();
10164         result = (wxFont *)new_wxFont((wxSize const &)*arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
10165
10166         wxPyEndAllowThreads(__tstate);
10167         if (PyErr_Occurred()) SWIG_fail;
10168     }
10169     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
10170     {
10171         if (temp6)
10172         delete arg6;
10173     }
10174     return resultobj;
10175     fail:
10176     {
10177         if (temp6)
10178         delete arg6;
10179     }
10180     return NULL;
10181 }
10182
10183
10184 static PyObject *_wrap_Font_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
10185     PyObject *resultobj;
10186     wxFont *arg1 = (wxFont *) 0 ;
10187     bool result;
10188     PyObject * obj0 = 0 ;
10189     char *kwnames[] = {
10190         (char *) "self", NULL
10191     };
10192
10193     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_Ok",kwnames,&obj0)) goto fail;
10194     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10195     if (SWIG_arg_fail(1)) SWIG_fail;
10196     {
10197         PyThreadState* __tstate = wxPyBeginAllowThreads();
10198         result = (bool)((wxFont const *)arg1)->Ok();
10199
10200         wxPyEndAllowThreads(__tstate);
10201         if (PyErr_Occurred()) SWIG_fail;
10202     }
10203     {
10204         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10205     }
10206     return resultobj;
10207     fail:
10208     return NULL;
10209 }
10210
10211
10212 static PyObject *_wrap_Font___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
10213     PyObject *resultobj;
10214     wxFont *arg1 = (wxFont *) 0 ;
10215     wxFont *arg2 = (wxFont *) 0 ;
10216     bool result;
10217     PyObject * obj0 = 0 ;
10218     PyObject * obj1 = 0 ;
10219     char *kwnames[] = {
10220         (char *) "self",(char *) "other", NULL
10221     };
10222
10223     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___eq__",kwnames,&obj0,&obj1)) goto fail;
10224     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10225     if (SWIG_arg_fail(1)) SWIG_fail;
10226     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10227     if (SWIG_arg_fail(2)) SWIG_fail;
10228     {
10229         PyThreadState* __tstate = wxPyBeginAllowThreads();
10230         result = (bool)wxFont___eq__(arg1,(wxFont const *)arg2);
10231
10232         wxPyEndAllowThreads(__tstate);
10233         if (PyErr_Occurred()) SWIG_fail;
10234     }
10235     {
10236         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10237     }
10238     return resultobj;
10239     fail:
10240     return NULL;
10241 }
10242
10243
10244 static PyObject *_wrap_Font___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
10245     PyObject *resultobj;
10246     wxFont *arg1 = (wxFont *) 0 ;
10247     wxFont *arg2 = (wxFont *) 0 ;
10248     bool result;
10249     PyObject * obj0 = 0 ;
10250     PyObject * obj1 = 0 ;
10251     char *kwnames[] = {
10252         (char *) "self",(char *) "other", NULL
10253     };
10254
10255     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___ne__",kwnames,&obj0,&obj1)) goto fail;
10256     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10257     if (SWIG_arg_fail(1)) SWIG_fail;
10258     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10259     if (SWIG_arg_fail(2)) SWIG_fail;
10260     {
10261         PyThreadState* __tstate = wxPyBeginAllowThreads();
10262         result = (bool)wxFont___ne__(arg1,(wxFont const *)arg2);
10263
10264         wxPyEndAllowThreads(__tstate);
10265         if (PyErr_Occurred()) SWIG_fail;
10266     }
10267     {
10268         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10269     }
10270     return resultobj;
10271     fail:
10272     return NULL;
10273 }
10274
10275
10276 static PyObject *_wrap_Font_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
10277     PyObject *resultobj;
10278     wxFont *arg1 = (wxFont *) 0 ;
10279     int result;
10280     PyObject * obj0 = 0 ;
10281     char *kwnames[] = {
10282         (char *) "self", NULL
10283     };
10284
10285     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPointSize",kwnames,&obj0)) goto fail;
10286     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10287     if (SWIG_arg_fail(1)) SWIG_fail;
10288     {
10289         PyThreadState* __tstate = wxPyBeginAllowThreads();
10290         result = (int)((wxFont const *)arg1)->GetPointSize();
10291
10292         wxPyEndAllowThreads(__tstate);
10293         if (PyErr_Occurred()) SWIG_fail;
10294     }
10295     {
10296         resultobj = SWIG_From_int((int)(result));
10297     }
10298     return resultobj;
10299     fail:
10300     return NULL;
10301 }
10302
10303
10304 static PyObject *_wrap_Font_GetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10305     PyObject *resultobj;
10306     wxFont *arg1 = (wxFont *) 0 ;
10307     wxSize result;
10308     PyObject * obj0 = 0 ;
10309     char *kwnames[] = {
10310         (char *) "self", NULL
10311     };
10312
10313     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPixelSize",kwnames,&obj0)) goto fail;
10314     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10315     if (SWIG_arg_fail(1)) SWIG_fail;
10316     {
10317         PyThreadState* __tstate = wxPyBeginAllowThreads();
10318         result = ((wxFont const *)arg1)->GetPixelSize();
10319
10320         wxPyEndAllowThreads(__tstate);
10321         if (PyErr_Occurred()) SWIG_fail;
10322     }
10323     {
10324         wxSize * resultptr;
10325         resultptr = new wxSize((wxSize &)(result));
10326         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
10327     }
10328     return resultobj;
10329     fail:
10330     return NULL;
10331 }
10332
10333
10334 static PyObject *_wrap_Font_IsUsingSizeInPixels(PyObject *, PyObject *args, PyObject *kwargs) {
10335     PyObject *resultobj;
10336     wxFont *arg1 = (wxFont *) 0 ;
10337     bool result;
10338     PyObject * obj0 = 0 ;
10339     char *kwnames[] = {
10340         (char *) "self", NULL
10341     };
10342
10343     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsUsingSizeInPixels",kwnames,&obj0)) goto fail;
10344     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10345     if (SWIG_arg_fail(1)) SWIG_fail;
10346     {
10347         PyThreadState* __tstate = wxPyBeginAllowThreads();
10348         result = (bool)((wxFont const *)arg1)->IsUsingSizeInPixels();
10349
10350         wxPyEndAllowThreads(__tstate);
10351         if (PyErr_Occurred()) SWIG_fail;
10352     }
10353     {
10354         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10355     }
10356     return resultobj;
10357     fail:
10358     return NULL;
10359 }
10360
10361
10362 static PyObject *_wrap_Font_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
10363     PyObject *resultobj;
10364     wxFont *arg1 = (wxFont *) 0 ;
10365     int result;
10366     PyObject * obj0 = 0 ;
10367     char *kwnames[] = {
10368         (char *) "self", NULL
10369     };
10370
10371     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamily",kwnames,&obj0)) goto fail;
10372     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10373     if (SWIG_arg_fail(1)) SWIG_fail;
10374     {
10375         PyThreadState* __tstate = wxPyBeginAllowThreads();
10376         result = (int)((wxFont const *)arg1)->GetFamily();
10377
10378         wxPyEndAllowThreads(__tstate);
10379         if (PyErr_Occurred()) SWIG_fail;
10380     }
10381     {
10382         resultobj = SWIG_From_int((int)(result));
10383     }
10384     return resultobj;
10385     fail:
10386     return NULL;
10387 }
10388
10389
10390 static PyObject *_wrap_Font_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10391     PyObject *resultobj;
10392     wxFont *arg1 = (wxFont *) 0 ;
10393     int result;
10394     PyObject * obj0 = 0 ;
10395     char *kwnames[] = {
10396         (char *) "self", NULL
10397     };
10398
10399     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyle",kwnames,&obj0)) goto fail;
10400     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10401     if (SWIG_arg_fail(1)) SWIG_fail;
10402     {
10403         PyThreadState* __tstate = wxPyBeginAllowThreads();
10404         result = (int)((wxFont const *)arg1)->GetStyle();
10405
10406         wxPyEndAllowThreads(__tstate);
10407         if (PyErr_Occurred()) SWIG_fail;
10408     }
10409     {
10410         resultobj = SWIG_From_int((int)(result));
10411     }
10412     return resultobj;
10413     fail:
10414     return NULL;
10415 }
10416
10417
10418 static PyObject *_wrap_Font_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
10419     PyObject *resultobj;
10420     wxFont *arg1 = (wxFont *) 0 ;
10421     int result;
10422     PyObject * obj0 = 0 ;
10423     char *kwnames[] = {
10424         (char *) "self", NULL
10425     };
10426
10427     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeight",kwnames,&obj0)) goto fail;
10428     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10429     if (SWIG_arg_fail(1)) SWIG_fail;
10430     {
10431         PyThreadState* __tstate = wxPyBeginAllowThreads();
10432         result = (int)((wxFont const *)arg1)->GetWeight();
10433
10434         wxPyEndAllowThreads(__tstate);
10435         if (PyErr_Occurred()) SWIG_fail;
10436     }
10437     {
10438         resultobj = SWIG_From_int((int)(result));
10439     }
10440     return resultobj;
10441     fail:
10442     return NULL;
10443 }
10444
10445
10446 static PyObject *_wrap_Font_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
10447     PyObject *resultobj;
10448     wxFont *arg1 = (wxFont *) 0 ;
10449     bool result;
10450     PyObject * obj0 = 0 ;
10451     char *kwnames[] = {
10452         (char *) "self", NULL
10453     };
10454
10455     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetUnderlined",kwnames,&obj0)) goto fail;
10456     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10457     if (SWIG_arg_fail(1)) SWIG_fail;
10458     {
10459         PyThreadState* __tstate = wxPyBeginAllowThreads();
10460         result = (bool)((wxFont const *)arg1)->GetUnderlined();
10461
10462         wxPyEndAllowThreads(__tstate);
10463         if (PyErr_Occurred()) SWIG_fail;
10464     }
10465     {
10466         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10467     }
10468     return resultobj;
10469     fail:
10470     return NULL;
10471 }
10472
10473
10474 static PyObject *_wrap_Font_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
10475     PyObject *resultobj;
10476     wxFont *arg1 = (wxFont *) 0 ;
10477     wxString result;
10478     PyObject * obj0 = 0 ;
10479     char *kwnames[] = {
10480         (char *) "self", NULL
10481     };
10482
10483     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFaceName",kwnames,&obj0)) goto fail;
10484     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10485     if (SWIG_arg_fail(1)) SWIG_fail;
10486     {
10487         PyThreadState* __tstate = wxPyBeginAllowThreads();
10488         result = ((wxFont const *)arg1)->GetFaceName();
10489
10490         wxPyEndAllowThreads(__tstate);
10491         if (PyErr_Occurred()) SWIG_fail;
10492     }
10493     {
10494 #if wxUSE_UNICODE
10495         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10496 #else
10497         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10498 #endif
10499     }
10500     return resultobj;
10501     fail:
10502     return NULL;
10503 }
10504
10505
10506 static PyObject *_wrap_Font_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10507     PyObject *resultobj;
10508     wxFont *arg1 = (wxFont *) 0 ;
10509     wxFontEncoding result;
10510     PyObject * obj0 = 0 ;
10511     char *kwnames[] = {
10512         (char *) "self", NULL
10513     };
10514
10515     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetEncoding",kwnames,&obj0)) goto fail;
10516     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10517     if (SWIG_arg_fail(1)) SWIG_fail;
10518     {
10519         PyThreadState* __tstate = wxPyBeginAllowThreads();
10520         result = (wxFontEncoding)((wxFont const *)arg1)->GetEncoding();
10521
10522         wxPyEndAllowThreads(__tstate);
10523         if (PyErr_Occurred()) SWIG_fail;
10524     }
10525     resultobj = SWIG_From_int((result));
10526     return resultobj;
10527     fail:
10528     return NULL;
10529 }
10530
10531
10532 static PyObject *_wrap_Font_GetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10533     PyObject *resultobj;
10534     wxFont *arg1 = (wxFont *) 0 ;
10535     wxNativeFontInfo *result;
10536     PyObject * obj0 = 0 ;
10537     char *kwnames[] = {
10538         (char *) "self", NULL
10539     };
10540
10541     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfo",kwnames,&obj0)) goto fail;
10542     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10543     if (SWIG_arg_fail(1)) SWIG_fail;
10544     {
10545         PyThreadState* __tstate = wxPyBeginAllowThreads();
10546         result = (wxNativeFontInfo *)((wxFont const *)arg1)->GetNativeFontInfo();
10547
10548         wxPyEndAllowThreads(__tstate);
10549         if (PyErr_Occurred()) SWIG_fail;
10550     }
10551     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 0);
10552     return resultobj;
10553     fail:
10554     return NULL;
10555 }
10556
10557
10558 static PyObject *_wrap_Font_IsFixedWidth(PyObject *, PyObject *args, PyObject *kwargs) {
10559     PyObject *resultobj;
10560     wxFont *arg1 = (wxFont *) 0 ;
10561     bool result;
10562     PyObject * obj0 = 0 ;
10563     char *kwnames[] = {
10564         (char *) "self", NULL
10565     };
10566
10567     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsFixedWidth",kwnames,&obj0)) goto fail;
10568     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10569     if (SWIG_arg_fail(1)) SWIG_fail;
10570     {
10571         PyThreadState* __tstate = wxPyBeginAllowThreads();
10572         result = (bool)((wxFont const *)arg1)->IsFixedWidth();
10573
10574         wxPyEndAllowThreads(__tstate);
10575         if (PyErr_Occurred()) SWIG_fail;
10576     }
10577     {
10578         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10579     }
10580     return resultobj;
10581     fail:
10582     return NULL;
10583 }
10584
10585
10586 static PyObject *_wrap_Font_GetNativeFontInfoDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10587     PyObject *resultobj;
10588     wxFont *arg1 = (wxFont *) 0 ;
10589     wxString result;
10590     PyObject * obj0 = 0 ;
10591     char *kwnames[] = {
10592         (char *) "self", NULL
10593     };
10594
10595     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoDesc",kwnames,&obj0)) goto fail;
10596     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10597     if (SWIG_arg_fail(1)) SWIG_fail;
10598     {
10599         PyThreadState* __tstate = wxPyBeginAllowThreads();
10600         result = ((wxFont const *)arg1)->GetNativeFontInfoDesc();
10601
10602         wxPyEndAllowThreads(__tstate);
10603         if (PyErr_Occurred()) SWIG_fail;
10604     }
10605     {
10606 #if wxUSE_UNICODE
10607         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10608 #else
10609         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10610 #endif
10611     }
10612     return resultobj;
10613     fail:
10614     return NULL;
10615 }
10616
10617
10618 static PyObject *_wrap_Font_GetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10619     PyObject *resultobj;
10620     wxFont *arg1 = (wxFont *) 0 ;
10621     wxString result;
10622     PyObject * obj0 = 0 ;
10623     char *kwnames[] = {
10624         (char *) "self", NULL
10625     };
10626
10627     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoUserDesc",kwnames,&obj0)) 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         PyThreadState* __tstate = wxPyBeginAllowThreads();
10632         result = ((wxFont const *)arg1)->GetNativeFontInfoUserDesc();
10633
10634         wxPyEndAllowThreads(__tstate);
10635         if (PyErr_Occurred()) SWIG_fail;
10636     }
10637     {
10638 #if wxUSE_UNICODE
10639         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10640 #else
10641         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10642 #endif
10643     }
10644     return resultobj;
10645     fail:
10646     return NULL;
10647 }
10648
10649
10650 static PyObject *_wrap_Font_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
10651     PyObject *resultobj;
10652     wxFont *arg1 = (wxFont *) 0 ;
10653     int arg2 ;
10654     PyObject * obj0 = 0 ;
10655     PyObject * obj1 = 0 ;
10656     char *kwnames[] = {
10657         (char *) "self",(char *) "pointSize", NULL
10658     };
10659
10660     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
10661     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10662     if (SWIG_arg_fail(1)) SWIG_fail;
10663     {
10664         arg2 = (int)(SWIG_As_int(obj1));
10665         if (SWIG_arg_fail(2)) SWIG_fail;
10666     }
10667     {
10668         PyThreadState* __tstate = wxPyBeginAllowThreads();
10669         (arg1)->SetPointSize(arg2);
10670
10671         wxPyEndAllowThreads(__tstate);
10672         if (PyErr_Occurred()) SWIG_fail;
10673     }
10674     Py_INCREF(Py_None); resultobj = Py_None;
10675     return resultobj;
10676     fail:
10677     return NULL;
10678 }
10679
10680
10681 static PyObject *_wrap_Font_SetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10682     PyObject *resultobj;
10683     wxFont *arg1 = (wxFont *) 0 ;
10684     wxSize *arg2 = 0 ;
10685     wxSize temp2 ;
10686     PyObject * obj0 = 0 ;
10687     PyObject * obj1 = 0 ;
10688     char *kwnames[] = {
10689         (char *) "self",(char *) "pixelSize", NULL
10690     };
10691
10692     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPixelSize",kwnames,&obj0,&obj1)) goto fail;
10693     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10694     if (SWIG_arg_fail(1)) SWIG_fail;
10695     {
10696         arg2 = &temp2;
10697         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
10698     }
10699     {
10700         PyThreadState* __tstate = wxPyBeginAllowThreads();
10701         (arg1)->SetPixelSize((wxSize const &)*arg2);
10702
10703         wxPyEndAllowThreads(__tstate);
10704         if (PyErr_Occurred()) SWIG_fail;
10705     }
10706     Py_INCREF(Py_None); resultobj = Py_None;
10707     return resultobj;
10708     fail:
10709     return NULL;
10710 }
10711
10712
10713 static PyObject *_wrap_Font_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
10714     PyObject *resultobj;
10715     wxFont *arg1 = (wxFont *) 0 ;
10716     int arg2 ;
10717     PyObject * obj0 = 0 ;
10718     PyObject * obj1 = 0 ;
10719     char *kwnames[] = {
10720         (char *) "self",(char *) "family", NULL
10721     };
10722
10723     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFamily",kwnames,&obj0,&obj1)) goto fail;
10724     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10725     if (SWIG_arg_fail(1)) SWIG_fail;
10726     {
10727         arg2 = (int)(SWIG_As_int(obj1));
10728         if (SWIG_arg_fail(2)) SWIG_fail;
10729     }
10730     {
10731         PyThreadState* __tstate = wxPyBeginAllowThreads();
10732         (arg1)->SetFamily(arg2);
10733
10734         wxPyEndAllowThreads(__tstate);
10735         if (PyErr_Occurred()) SWIG_fail;
10736     }
10737     Py_INCREF(Py_None); resultobj = Py_None;
10738     return resultobj;
10739     fail:
10740     return NULL;
10741 }
10742
10743
10744 static PyObject *_wrap_Font_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10745     PyObject *resultobj;
10746     wxFont *arg1 = (wxFont *) 0 ;
10747     int arg2 ;
10748     PyObject * obj0 = 0 ;
10749     PyObject * obj1 = 0 ;
10750     char *kwnames[] = {
10751         (char *) "self",(char *) "style", NULL
10752     };
10753
10754     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetStyle",kwnames,&obj0,&obj1)) goto fail;
10755     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10756     if (SWIG_arg_fail(1)) SWIG_fail;
10757     {
10758         arg2 = (int)(SWIG_As_int(obj1));
10759         if (SWIG_arg_fail(2)) SWIG_fail;
10760     }
10761     {
10762         PyThreadState* __tstate = wxPyBeginAllowThreads();
10763         (arg1)->SetStyle(arg2);
10764
10765         wxPyEndAllowThreads(__tstate);
10766         if (PyErr_Occurred()) SWIG_fail;
10767     }
10768     Py_INCREF(Py_None); resultobj = Py_None;
10769     return resultobj;
10770     fail:
10771     return NULL;
10772 }
10773
10774
10775 static PyObject *_wrap_Font_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
10776     PyObject *resultobj;
10777     wxFont *arg1 = (wxFont *) 0 ;
10778     int arg2 ;
10779     PyObject * obj0 = 0 ;
10780     PyObject * obj1 = 0 ;
10781     char *kwnames[] = {
10782         (char *) "self",(char *) "weight", NULL
10783     };
10784
10785     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetWeight",kwnames,&obj0,&obj1)) goto fail;
10786     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10787     if (SWIG_arg_fail(1)) SWIG_fail;
10788     {
10789         arg2 = (int)(SWIG_As_int(obj1));
10790         if (SWIG_arg_fail(2)) SWIG_fail;
10791     }
10792     {
10793         PyThreadState* __tstate = wxPyBeginAllowThreads();
10794         (arg1)->SetWeight(arg2);
10795
10796         wxPyEndAllowThreads(__tstate);
10797         if (PyErr_Occurred()) SWIG_fail;
10798     }
10799     Py_INCREF(Py_None); resultobj = Py_None;
10800     return resultobj;
10801     fail:
10802     return NULL;
10803 }
10804
10805
10806 static PyObject *_wrap_Font_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
10807     PyObject *resultobj;
10808     wxFont *arg1 = (wxFont *) 0 ;
10809     wxString *arg2 = 0 ;
10810     bool temp2 = false ;
10811     PyObject * obj0 = 0 ;
10812     PyObject * obj1 = 0 ;
10813     char *kwnames[] = {
10814         (char *) "self",(char *) "faceName", NULL
10815     };
10816
10817     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
10818     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10819     if (SWIG_arg_fail(1)) SWIG_fail;
10820     {
10821         arg2 = wxString_in_helper(obj1);
10822         if (arg2 == NULL) SWIG_fail;
10823         temp2 = true;
10824     }
10825     {
10826         PyThreadState* __tstate = wxPyBeginAllowThreads();
10827         (arg1)->SetFaceName((wxString const &)*arg2);
10828
10829         wxPyEndAllowThreads(__tstate);
10830         if (PyErr_Occurred()) SWIG_fail;
10831     }
10832     Py_INCREF(Py_None); resultobj = Py_None;
10833     {
10834         if (temp2)
10835         delete arg2;
10836     }
10837     return resultobj;
10838     fail:
10839     {
10840         if (temp2)
10841         delete arg2;
10842     }
10843     return NULL;
10844 }
10845
10846
10847 static PyObject *_wrap_Font_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
10848     PyObject *resultobj;
10849     wxFont *arg1 = (wxFont *) 0 ;
10850     bool arg2 ;
10851     PyObject * obj0 = 0 ;
10852     PyObject * obj1 = 0 ;
10853     char *kwnames[] = {
10854         (char *) "self",(char *) "underlined", NULL
10855     };
10856
10857     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
10858     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10859     if (SWIG_arg_fail(1)) SWIG_fail;
10860     {
10861         arg2 = (bool)(SWIG_As_bool(obj1));
10862         if (SWIG_arg_fail(2)) SWIG_fail;
10863     }
10864     {
10865         PyThreadState* __tstate = wxPyBeginAllowThreads();
10866         (arg1)->SetUnderlined(arg2);
10867
10868         wxPyEndAllowThreads(__tstate);
10869         if (PyErr_Occurred()) SWIG_fail;
10870     }
10871     Py_INCREF(Py_None); resultobj = Py_None;
10872     return resultobj;
10873     fail:
10874     return NULL;
10875 }
10876
10877
10878 static PyObject *_wrap_Font_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10879     PyObject *resultobj;
10880     wxFont *arg1 = (wxFont *) 0 ;
10881     wxFontEncoding arg2 ;
10882     PyObject * obj0 = 0 ;
10883     PyObject * obj1 = 0 ;
10884     char *kwnames[] = {
10885         (char *) "self",(char *) "encoding", NULL
10886     };
10887
10888     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
10889     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10890     if (SWIG_arg_fail(1)) SWIG_fail;
10891     {
10892         arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10893         if (SWIG_arg_fail(2)) SWIG_fail;
10894     }
10895     {
10896         PyThreadState* __tstate = wxPyBeginAllowThreads();
10897         (arg1)->SetEncoding((wxFontEncoding )arg2);
10898
10899         wxPyEndAllowThreads(__tstate);
10900         if (PyErr_Occurred()) SWIG_fail;
10901     }
10902     Py_INCREF(Py_None); resultobj = Py_None;
10903     return resultobj;
10904     fail:
10905     return NULL;
10906 }
10907
10908
10909 static PyObject *_wrap_Font_SetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10910     PyObject *resultobj;
10911     wxFont *arg1 = (wxFont *) 0 ;
10912     wxNativeFontInfo *arg2 = 0 ;
10913     PyObject * obj0 = 0 ;
10914     PyObject * obj1 = 0 ;
10915     char *kwnames[] = {
10916         (char *) "self",(char *) "info", NULL
10917     };
10918
10919     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfo",kwnames,&obj0,&obj1)) goto fail;
10920     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10921     if (SWIG_arg_fail(1)) SWIG_fail;
10922     {
10923         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
10924         if (SWIG_arg_fail(2)) SWIG_fail;
10925         if (arg2 == NULL) {
10926             SWIG_null_ref("wxNativeFontInfo");
10927         }
10928         if (SWIG_arg_fail(2)) SWIG_fail;
10929     }
10930     {
10931         PyThreadState* __tstate = wxPyBeginAllowThreads();
10932         (arg1)->SetNativeFontInfo((wxNativeFontInfo const &)*arg2);
10933
10934         wxPyEndAllowThreads(__tstate);
10935         if (PyErr_Occurred()) SWIG_fail;
10936     }
10937     Py_INCREF(Py_None); resultobj = Py_None;
10938     return resultobj;
10939     fail:
10940     return NULL;
10941 }
10942
10943
10944 static PyObject *_wrap_Font_SetNativeFontInfoFromString(PyObject *, PyObject *args, PyObject *kwargs) {
10945     PyObject *resultobj;
10946     wxFont *arg1 = (wxFont *) 0 ;
10947     wxString *arg2 = 0 ;
10948     bool temp2 = false ;
10949     PyObject * obj0 = 0 ;
10950     PyObject * obj1 = 0 ;
10951     char *kwnames[] = {
10952         (char *) "self",(char *) "info", NULL
10953     };
10954
10955     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoFromString",kwnames,&obj0,&obj1)) goto fail;
10956     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10957     if (SWIG_arg_fail(1)) SWIG_fail;
10958     {
10959         arg2 = wxString_in_helper(obj1);
10960         if (arg2 == NULL) SWIG_fail;
10961         temp2 = true;
10962     }
10963     {
10964         PyThreadState* __tstate = wxPyBeginAllowThreads();
10965         (arg1)->SetNativeFontInfo((wxString const &)*arg2);
10966
10967         wxPyEndAllowThreads(__tstate);
10968         if (PyErr_Occurred()) SWIG_fail;
10969     }
10970     Py_INCREF(Py_None); resultobj = Py_None;
10971     {
10972         if (temp2)
10973         delete arg2;
10974     }
10975     return resultobj;
10976     fail:
10977     {
10978         if (temp2)
10979         delete arg2;
10980     }
10981     return NULL;
10982 }
10983
10984
10985 static PyObject *_wrap_Font_SetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10986     PyObject *resultobj;
10987     wxFont *arg1 = (wxFont *) 0 ;
10988     wxString *arg2 = 0 ;
10989     bool temp2 = false ;
10990     PyObject * obj0 = 0 ;
10991     PyObject * obj1 = 0 ;
10992     char *kwnames[] = {
10993         (char *) "self",(char *) "info", NULL
10994     };
10995
10996     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoUserDesc",kwnames,&obj0,&obj1)) goto fail;
10997     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10998     if (SWIG_arg_fail(1)) SWIG_fail;
10999     {
11000         arg2 = wxString_in_helper(obj1);
11001         if (arg2 == NULL) SWIG_fail;
11002         temp2 = true;
11003     }
11004     {
11005         PyThreadState* __tstate = wxPyBeginAllowThreads();
11006         (arg1)->SetNativeFontInfoUserDesc((wxString const &)*arg2);
11007
11008         wxPyEndAllowThreads(__tstate);
11009         if (PyErr_Occurred()) SWIG_fail;
11010     }
11011     Py_INCREF(Py_None); resultobj = Py_None;
11012     {
11013         if (temp2)
11014         delete arg2;
11015     }
11016     return resultobj;
11017     fail:
11018     {
11019         if (temp2)
11020         delete arg2;
11021     }
11022     return NULL;
11023 }
11024
11025
11026 static PyObject *_wrap_Font_GetFamilyString(PyObject *, PyObject *args, PyObject *kwargs) {
11027     PyObject *resultobj;
11028     wxFont *arg1 = (wxFont *) 0 ;
11029     wxString result;
11030     PyObject * obj0 = 0 ;
11031     char *kwnames[] = {
11032         (char *) "self", NULL
11033     };
11034
11035     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamilyString",kwnames,&obj0)) goto fail;
11036     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11037     if (SWIG_arg_fail(1)) SWIG_fail;
11038     {
11039         PyThreadState* __tstate = wxPyBeginAllowThreads();
11040         result = ((wxFont const *)arg1)->GetFamilyString();
11041
11042         wxPyEndAllowThreads(__tstate);
11043         if (PyErr_Occurred()) SWIG_fail;
11044     }
11045     {
11046 #if wxUSE_UNICODE
11047         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11048 #else
11049         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11050 #endif
11051     }
11052     return resultobj;
11053     fail:
11054     return NULL;
11055 }
11056
11057
11058 static PyObject *_wrap_Font_GetStyleString(PyObject *, PyObject *args, PyObject *kwargs) {
11059     PyObject *resultobj;
11060     wxFont *arg1 = (wxFont *) 0 ;
11061     wxString result;
11062     PyObject * obj0 = 0 ;
11063     char *kwnames[] = {
11064         (char *) "self", NULL
11065     };
11066
11067     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyleString",kwnames,&obj0)) goto fail;
11068     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11069     if (SWIG_arg_fail(1)) SWIG_fail;
11070     {
11071         PyThreadState* __tstate = wxPyBeginAllowThreads();
11072         result = ((wxFont const *)arg1)->GetStyleString();
11073
11074         wxPyEndAllowThreads(__tstate);
11075         if (PyErr_Occurred()) SWIG_fail;
11076     }
11077     {
11078 #if wxUSE_UNICODE
11079         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11080 #else
11081         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11082 #endif
11083     }
11084     return resultobj;
11085     fail:
11086     return NULL;
11087 }
11088
11089
11090 static PyObject *_wrap_Font_GetWeightString(PyObject *, PyObject *args, PyObject *kwargs) {
11091     PyObject *resultobj;
11092     wxFont *arg1 = (wxFont *) 0 ;
11093     wxString result;
11094     PyObject * obj0 = 0 ;
11095     char *kwnames[] = {
11096         (char *) "self", NULL
11097     };
11098
11099     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeightString",kwnames,&obj0)) 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     {
11103         PyThreadState* __tstate = wxPyBeginAllowThreads();
11104         result = ((wxFont const *)arg1)->GetWeightString();
11105
11106         wxPyEndAllowThreads(__tstate);
11107         if (PyErr_Occurred()) SWIG_fail;
11108     }
11109     {
11110 #if wxUSE_UNICODE
11111         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11112 #else
11113         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11114 #endif
11115     }
11116     return resultobj;
11117     fail:
11118     return NULL;
11119 }
11120
11121
11122 static PyObject *_wrap_Font_SetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
11123     PyObject *resultobj;
11124     wxFont *arg1 = (wxFont *) 0 ;
11125     bool arg2 = (bool) true ;
11126     PyObject * obj0 = 0 ;
11127     PyObject * obj1 = 0 ;
11128     char *kwnames[] = {
11129         (char *) "self",(char *) "no", NULL
11130     };
11131
11132     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Font_SetNoAntiAliasing",kwnames,&obj0,&obj1)) goto fail;
11133     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11134     if (SWIG_arg_fail(1)) SWIG_fail;
11135     if (obj1) {
11136         {
11137             arg2 = (bool)(SWIG_As_bool(obj1));
11138             if (SWIG_arg_fail(2)) SWIG_fail;
11139         }
11140     }
11141     {
11142         PyThreadState* __tstate = wxPyBeginAllowThreads();
11143         (arg1)->SetNoAntiAliasing(arg2);
11144
11145         wxPyEndAllowThreads(__tstate);
11146         if (PyErr_Occurred()) SWIG_fail;
11147     }
11148     Py_INCREF(Py_None); resultobj = Py_None;
11149     return resultobj;
11150     fail:
11151     return NULL;
11152 }
11153
11154
11155 static PyObject *_wrap_Font_GetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
11156     PyObject *resultobj;
11157     wxFont *arg1 = (wxFont *) 0 ;
11158     bool result;
11159     PyObject * obj0 = 0 ;
11160     char *kwnames[] = {
11161         (char *) "self", NULL
11162     };
11163
11164     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNoAntiAliasing",kwnames,&obj0)) goto fail;
11165     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11166     if (SWIG_arg_fail(1)) SWIG_fail;
11167     {
11168         PyThreadState* __tstate = wxPyBeginAllowThreads();
11169         result = (bool)((wxFont const *)arg1)->GetNoAntiAliasing();
11170
11171         wxPyEndAllowThreads(__tstate);
11172         if (PyErr_Occurred()) SWIG_fail;
11173     }
11174     {
11175         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11176     }
11177     return resultobj;
11178     fail:
11179     return NULL;
11180 }
11181
11182
11183 static PyObject *_wrap_Font_GetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11184     PyObject *resultobj;
11185     wxFontEncoding result;
11186     char *kwnames[] = {
11187         NULL
11188     };
11189
11190     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Font_GetDefaultEncoding",kwnames)) goto fail;
11191     {
11192         if (!wxPyCheckForApp()) SWIG_fail;
11193         PyThreadState* __tstate = wxPyBeginAllowThreads();
11194         result = (wxFontEncoding)wxFont::GetDefaultEncoding();
11195
11196         wxPyEndAllowThreads(__tstate);
11197         if (PyErr_Occurred()) SWIG_fail;
11198     }
11199     resultobj = SWIG_From_int((result));
11200     return resultobj;
11201     fail:
11202     return NULL;
11203 }
11204
11205
11206 static PyObject *_wrap_Font_SetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11207     PyObject *resultobj;
11208     wxFontEncoding arg1 ;
11209     PyObject * obj0 = 0 ;
11210     char *kwnames[] = {
11211         (char *) "encoding", NULL
11212     };
11213
11214     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_SetDefaultEncoding",kwnames,&obj0)) goto fail;
11215     {
11216         arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
11217         if (SWIG_arg_fail(1)) SWIG_fail;
11218     }
11219     {
11220         if (!wxPyCheckForApp()) SWIG_fail;
11221         PyThreadState* __tstate = wxPyBeginAllowThreads();
11222         wxFont::SetDefaultEncoding((wxFontEncoding )arg1);
11223
11224         wxPyEndAllowThreads(__tstate);
11225         if (PyErr_Occurred()) SWIG_fail;
11226     }
11227     Py_INCREF(Py_None); resultobj = Py_None;
11228     return resultobj;
11229     fail:
11230     return NULL;
11231 }
11232
11233
11234 static PyObject * Font_swigregister(PyObject *, PyObject *args) {
11235     PyObject *obj;
11236     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11237     SWIG_TypeClientData(SWIGTYPE_p_wxFont, obj);
11238     Py_INCREF(obj);
11239     return Py_BuildValue((char *)"");
11240 }
11241 static PyObject *_wrap_new_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
11242     PyObject *resultobj;
11243     wxPyFontEnumerator *result;
11244     char *kwnames[] = {
11245         NULL
11246     };
11247
11248     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontEnumerator",kwnames)) goto fail;
11249     {
11250         if (!wxPyCheckForApp()) SWIG_fail;
11251         PyThreadState* __tstate = wxPyBeginAllowThreads();
11252         result = (wxPyFontEnumerator *)new wxPyFontEnumerator();
11253
11254         wxPyEndAllowThreads(__tstate);
11255         if (PyErr_Occurred()) SWIG_fail;
11256     }
11257     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFontEnumerator, 1);
11258     return resultobj;
11259     fail:
11260     return NULL;
11261 }
11262
11263
11264 static PyObject *_wrap_delete_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
11265     PyObject *resultobj;
11266     wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11267     PyObject * obj0 = 0 ;
11268     char *kwnames[] = {
11269         (char *) "self", NULL
11270     };
11271
11272     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontEnumerator",kwnames,&obj0)) goto fail;
11273     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11274     if (SWIG_arg_fail(1)) SWIG_fail;
11275     {
11276         PyThreadState* __tstate = wxPyBeginAllowThreads();
11277         delete arg1;
11278
11279         wxPyEndAllowThreads(__tstate);
11280         if (PyErr_Occurred()) SWIG_fail;
11281     }
11282     Py_INCREF(Py_None); resultobj = Py_None;
11283     return resultobj;
11284     fail:
11285     return NULL;
11286 }
11287
11288
11289 static PyObject *_wrap_FontEnumerator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11290     PyObject *resultobj;
11291     wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11292     PyObject *arg2 = (PyObject *) 0 ;
11293     PyObject *arg3 = (PyObject *) 0 ;
11294     bool arg4 ;
11295     PyObject * obj0 = 0 ;
11296     PyObject * obj1 = 0 ;
11297     PyObject * obj2 = 0 ;
11298     PyObject * obj3 = 0 ;
11299     char *kwnames[] = {
11300         (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11301     };
11302
11303     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FontEnumerator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11304     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11305     if (SWIG_arg_fail(1)) SWIG_fail;
11306     arg2 = obj1;
11307     arg3 = obj2;
11308     {
11309         arg4 = (bool)(SWIG_As_bool(obj3));
11310         if (SWIG_arg_fail(4)) SWIG_fail;
11311     }
11312     {
11313         PyThreadState* __tstate = wxPyBeginAllowThreads();
11314         (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11315
11316         wxPyEndAllowThreads(__tstate);
11317         if (PyErr_Occurred()) SWIG_fail;
11318     }
11319     Py_INCREF(Py_None); resultobj = Py_None;
11320     return resultobj;
11321     fail:
11322     return NULL;
11323 }
11324
11325
11326 static PyObject *_wrap_FontEnumerator_EnumerateFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
11327     PyObject *resultobj;
11328     wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11329     wxFontEncoding arg2 = (wxFontEncoding) wxFONTENCODING_SYSTEM ;
11330     bool arg3 = (bool) false ;
11331     bool result;
11332     PyObject * obj0 = 0 ;
11333     PyObject * obj1 = 0 ;
11334     PyObject * obj2 = 0 ;
11335     char *kwnames[] = {
11336         (char *) "self",(char *) "encoding",(char *) "fixedWidthOnly", NULL
11337     };
11338
11339     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FontEnumerator_EnumerateFacenames",kwnames,&obj0,&obj1,&obj2)) goto fail;
11340     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11341     if (SWIG_arg_fail(1)) SWIG_fail;
11342     if (obj1) {
11343         {
11344             arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
11345             if (SWIG_arg_fail(2)) SWIG_fail;
11346         }
11347     }
11348     if (obj2) {
11349         {
11350             arg3 = (bool)(SWIG_As_bool(obj2));
11351             if (SWIG_arg_fail(3)) SWIG_fail;
11352         }
11353     }
11354     {
11355         PyThreadState* __tstate = wxPyBeginAllowThreads();
11356         result = (bool)(arg1)->EnumerateFacenames((wxFontEncoding )arg2,arg3);
11357
11358         wxPyEndAllowThreads(__tstate);
11359         if (PyErr_Occurred()) SWIG_fail;
11360     }
11361     {
11362         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11363     }
11364     return resultobj;
11365     fail:
11366     return NULL;
11367 }
11368
11369
11370 static PyObject *_wrap_FontEnumerator_EnumerateEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
11371     PyObject *resultobj;
11372     wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11373     wxString const &arg2_defvalue = wxPyEmptyString ;
11374     wxString *arg2 = (wxString *) &arg2_defvalue ;
11375     bool result;
11376     bool temp2 = false ;
11377     PyObject * obj0 = 0 ;
11378     PyObject * obj1 = 0 ;
11379     char *kwnames[] = {
11380         (char *) "self",(char *) "facename", NULL
11381     };
11382
11383     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FontEnumerator_EnumerateEncodings",kwnames,&obj0,&obj1)) goto fail;
11384     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11385     if (SWIG_arg_fail(1)) SWIG_fail;
11386     if (obj1) {
11387         {
11388             arg2 = wxString_in_helper(obj1);
11389             if (arg2 == NULL) SWIG_fail;
11390             temp2 = true;
11391         }
11392     }
11393     {
11394         PyThreadState* __tstate = wxPyBeginAllowThreads();
11395         result = (bool)(arg1)->EnumerateEncodings((wxString const &)*arg2);
11396
11397         wxPyEndAllowThreads(__tstate);
11398         if (PyErr_Occurred()) SWIG_fail;
11399     }
11400     {
11401         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11402     }
11403     {
11404         if (temp2)
11405         delete arg2;
11406     }
11407     return resultobj;
11408     fail:
11409     {
11410         if (temp2)
11411         delete arg2;
11412     }
11413     return NULL;
11414 }
11415
11416
11417 static PyObject *_wrap_FontEnumerator_GetEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
11418     PyObject *resultobj;
11419     wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11420     PyObject *result;
11421     PyObject * obj0 = 0 ;
11422     char *kwnames[] = {
11423         (char *) "self", NULL
11424     };
11425
11426     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetEncodings",kwnames,&obj0)) goto fail;
11427     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11428     if (SWIG_arg_fail(1)) SWIG_fail;
11429     {
11430         PyThreadState* __tstate = wxPyBeginAllowThreads();
11431         result = (PyObject *)wxPyFontEnumerator_GetEncodings(arg1);
11432
11433         wxPyEndAllowThreads(__tstate);
11434         if (PyErr_Occurred()) SWIG_fail;
11435     }
11436     resultobj = result;
11437     return resultobj;
11438     fail:
11439     return NULL;
11440 }
11441
11442
11443 static PyObject *_wrap_FontEnumerator_GetFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
11444     PyObject *resultobj;
11445     wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11446     PyObject *result;
11447     PyObject * obj0 = 0 ;
11448     char *kwnames[] = {
11449         (char *) "self", NULL
11450     };
11451
11452     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetFacenames",kwnames,&obj0)) goto fail;
11453     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11454     if (SWIG_arg_fail(1)) SWIG_fail;
11455     {
11456         PyThreadState* __tstate = wxPyBeginAllowThreads();
11457         result = (PyObject *)wxPyFontEnumerator_GetFacenames(arg1);
11458
11459         wxPyEndAllowThreads(__tstate);
11460         if (PyErr_Occurred()) SWIG_fail;
11461     }
11462     resultobj = result;
11463     return resultobj;
11464     fail:
11465     return NULL;
11466 }
11467
11468
11469 static PyObject * FontEnumerator_swigregister(PyObject *, PyObject *args) {
11470     PyObject *obj;
11471     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11472     SWIG_TypeClientData(SWIGTYPE_p_wxPyFontEnumerator, obj);
11473     Py_INCREF(obj);
11474     return Py_BuildValue((char *)"");
11475 }
11476 static PyObject *_wrap_LanguageInfo_Language_set(PyObject *, PyObject *args, PyObject *kwargs) {
11477     PyObject *resultobj;
11478     wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11479     int arg2 ;
11480     PyObject * obj0 = 0 ;
11481     PyObject * obj1 = 0 ;
11482     char *kwnames[] = {
11483         (char *) "self",(char *) "Language", NULL
11484     };
11485
11486     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Language_set",kwnames,&obj0,&obj1)) goto fail;
11487     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11488     if (SWIG_arg_fail(1)) SWIG_fail;
11489     {
11490         arg2 = (int)(SWIG_As_int(obj1));
11491         if (SWIG_arg_fail(2)) SWIG_fail;
11492     }
11493     if (arg1) (arg1)->Language = arg2;
11494
11495     Py_INCREF(Py_None); resultobj = Py_None;
11496     return resultobj;
11497     fail:
11498     return NULL;
11499 }
11500
11501
11502 static PyObject *_wrap_LanguageInfo_Language_get(PyObject *, PyObject *args, PyObject *kwargs) {
11503     PyObject *resultobj;
11504     wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11505     int result;
11506     PyObject * obj0 = 0 ;
11507     char *kwnames[] = {
11508         (char *) "self", NULL
11509     };
11510
11511     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Language_get",kwnames,&obj0)) goto fail;
11512     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11513     if (SWIG_arg_fail(1)) SWIG_fail;
11514     result = (int) ((arg1)->Language);
11515
11516     {
11517         resultobj = SWIG_From_int((int)(result));
11518     }
11519     return resultobj;
11520     fail:
11521     return NULL;
11522 }
11523
11524
11525 static PyObject *_wrap_LanguageInfo_CanonicalName_set(PyObject *, PyObject *args, PyObject *kwargs) {
11526     PyObject *resultobj;
11527     wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11528     wxString *arg2 = (wxString *) 0 ;
11529     bool temp2 = false ;
11530     PyObject * obj0 = 0 ;
11531     PyObject * obj1 = 0 ;
11532     char *kwnames[] = {
11533         (char *) "self",(char *) "CanonicalName", NULL
11534     };
11535
11536     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_CanonicalName_set",kwnames,&obj0,&obj1)) goto fail;
11537     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11538     if (SWIG_arg_fail(1)) SWIG_fail;
11539     {
11540         arg2 = wxString_in_helper(obj1);
11541         if (arg2 == NULL) SWIG_fail;
11542         temp2 = true;
11543     }
11544     if (arg1) (arg1)->CanonicalName = *arg2;
11545
11546     Py_INCREF(Py_None); resultobj = Py_None;
11547     {
11548         if (temp2)
11549         delete arg2;
11550     }
11551     return resultobj;
11552     fail:
11553     {
11554         if (temp2)
11555         delete arg2;
11556     }
11557     return NULL;
11558 }
11559
11560
11561 static PyObject *_wrap_LanguageInfo_CanonicalName_get(PyObject *, PyObject *args, PyObject *kwargs) {
11562     PyObject *resultobj;
11563     wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11564     wxString *result;
11565     PyObject * obj0 = 0 ;
11566     char *kwnames[] = {
11567         (char *) "self", NULL
11568     };
11569
11570     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_CanonicalName_get",kwnames,&obj0)) goto fail;
11571     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11572     if (SWIG_arg_fail(1)) SWIG_fail;
11573     result = (wxString *)& ((arg1)->CanonicalName);
11574
11575     {
11576 #if wxUSE_UNICODE
11577         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11578 #else
11579         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11580 #endif
11581     }
11582     return resultobj;
11583     fail:
11584     return NULL;
11585 }
11586
11587
11588 static PyObject *_wrap_LanguageInfo_Description_set(PyObject *, PyObject *args, PyObject *kwargs) {
11589     PyObject *resultobj;
11590     wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11591     wxString *arg2 = (wxString *) 0 ;
11592     bool temp2 = false ;
11593     PyObject * obj0 = 0 ;
11594     PyObject * obj1 = 0 ;
11595     char *kwnames[] = {
11596         (char *) "self",(char *) "Description", NULL
11597     };
11598
11599     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Description_set",kwnames,&obj0,&obj1)) goto fail;
11600     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11601     if (SWIG_arg_fail(1)) SWIG_fail;
11602     {
11603         arg2 = wxString_in_helper(obj1);
11604         if (arg2 == NULL) SWIG_fail;
11605         temp2 = true;
11606     }
11607     if (arg1) (arg1)->Description = *arg2;
11608
11609     Py_INCREF(Py_None); resultobj = Py_None;
11610     {
11611         if (temp2)
11612         delete arg2;
11613     }
11614     return resultobj;
11615     fail:
11616     {
11617         if (temp2)
11618         delete arg2;
11619     }
11620     return NULL;
11621 }
11622
11623
11624 static PyObject *_wrap_LanguageInfo_Description_get(PyObject *, PyObject *args, PyObject *kwargs) {
11625     PyObject *resultobj;
11626     wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11627     wxString *result;
11628     PyObject * obj0 = 0 ;
11629     char *kwnames[] = {
11630         (char *) "self", NULL
11631     };
11632
11633     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Description_get",kwnames,&obj0)) goto fail;
11634     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11635     if (SWIG_arg_fail(1)) SWIG_fail;
11636     result = (wxString *)& ((arg1)->Description);
11637
11638     {
11639 #if wxUSE_UNICODE
11640         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11641 #else
11642         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11643 #endif
11644     }
11645     return resultobj;
11646     fail:
11647     return NULL;
11648 }
11649
11650
11651 static PyObject * LanguageInfo_swigregister(PyObject *, PyObject *args) {
11652     PyObject *obj;
11653     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11654     SWIG_TypeClientData(SWIGTYPE_p_wxLanguageInfo, obj);
11655     Py_INCREF(obj);
11656     return Py_BuildValue((char *)"");
11657 }
11658 static PyObject *_wrap_new_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11659     PyObject *resultobj;
11660     int arg1 = (int) -1 ;
11661     int arg2 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11662     wxLocale *result;
11663     PyObject * obj0 = 0 ;
11664     PyObject * obj1 = 0 ;
11665     char *kwnames[] = {
11666         (char *) "language",(char *) "flags", NULL
11667     };
11668
11669     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Locale",kwnames,&obj0,&obj1)) goto fail;
11670     if (obj0) {
11671         {
11672             arg1 = (int)(SWIG_As_int(obj0));
11673             if (SWIG_arg_fail(1)) SWIG_fail;
11674         }
11675     }
11676     if (obj1) {
11677         {
11678             arg2 = (int)(SWIG_As_int(obj1));
11679             if (SWIG_arg_fail(2)) SWIG_fail;
11680         }
11681     }
11682     {
11683         PyThreadState* __tstate = wxPyBeginAllowThreads();
11684         result = (wxLocale *)new_wxLocale(arg1,arg2);
11685
11686         wxPyEndAllowThreads(__tstate);
11687         if (PyErr_Occurred()) SWIG_fail;
11688     }
11689     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 1);
11690     return resultobj;
11691     fail:
11692     return NULL;
11693 }
11694
11695
11696 static PyObject *_wrap_delete_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11697     PyObject *resultobj;
11698     wxLocale *arg1 = (wxLocale *) 0 ;
11699     PyObject * obj0 = 0 ;
11700     char *kwnames[] = {
11701         (char *) "self", NULL
11702     };
11703
11704     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Locale",kwnames,&obj0)) goto fail;
11705     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11706     if (SWIG_arg_fail(1)) SWIG_fail;
11707     {
11708         PyThreadState* __tstate = wxPyBeginAllowThreads();
11709         delete arg1;
11710
11711         wxPyEndAllowThreads(__tstate);
11712         if (PyErr_Occurred()) SWIG_fail;
11713     }
11714     Py_INCREF(Py_None); resultobj = Py_None;
11715     return resultobj;
11716     fail:
11717     return NULL;
11718 }
11719
11720
11721 static PyObject *_wrap_Locale_Init1(PyObject *, PyObject *args, PyObject *kwargs) {
11722     PyObject *resultobj;
11723     wxLocale *arg1 = (wxLocale *) 0 ;
11724     wxString *arg2 = 0 ;
11725     wxString const &arg3_defvalue = wxPyEmptyString ;
11726     wxString *arg3 = (wxString *) &arg3_defvalue ;
11727     wxString const &arg4_defvalue = wxPyEmptyString ;
11728     wxString *arg4 = (wxString *) &arg4_defvalue ;
11729     bool arg5 = (bool) true ;
11730     bool arg6 = (bool) false ;
11731     bool result;
11732     bool temp2 = false ;
11733     bool temp3 = false ;
11734     bool temp4 = false ;
11735     PyObject * obj0 = 0 ;
11736     PyObject * obj1 = 0 ;
11737     PyObject * obj2 = 0 ;
11738     PyObject * obj3 = 0 ;
11739     PyObject * obj4 = 0 ;
11740     PyObject * obj5 = 0 ;
11741     char *kwnames[] = {
11742         (char *) "self",(char *) "szName",(char *) "szShort",(char *) "szLocale",(char *) "bLoadDefault",(char *) "bConvertEncoding", NULL
11743     };
11744
11745     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Locale_Init1",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11746     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11747     if (SWIG_arg_fail(1)) SWIG_fail;
11748     {
11749         arg2 = wxString_in_helper(obj1);
11750         if (arg2 == NULL) SWIG_fail;
11751         temp2 = true;
11752     }
11753     if (obj2) {
11754         {
11755             arg3 = wxString_in_helper(obj2);
11756             if (arg3 == NULL) SWIG_fail;
11757             temp3 = true;
11758         }
11759     }
11760     if (obj3) {
11761         {
11762             arg4 = wxString_in_helper(obj3);
11763             if (arg4 == NULL) SWIG_fail;
11764             temp4 = true;
11765         }
11766     }
11767     if (obj4) {
11768         {
11769             arg5 = (bool)(SWIG_As_bool(obj4));
11770             if (SWIG_arg_fail(5)) SWIG_fail;
11771         }
11772     }
11773     if (obj5) {
11774         {
11775             arg6 = (bool)(SWIG_As_bool(obj5));
11776             if (SWIG_arg_fail(6)) SWIG_fail;
11777         }
11778     }
11779     {
11780         PyThreadState* __tstate = wxPyBeginAllowThreads();
11781         result = (bool)wxLocale_Init1(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
11782
11783         wxPyEndAllowThreads(__tstate);
11784         if (PyErr_Occurred()) SWIG_fail;
11785     }
11786     {
11787         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11788     }
11789     {
11790         if (temp2)
11791         delete arg2;
11792     }
11793     {
11794         if (temp3)
11795         delete arg3;
11796     }
11797     {
11798         if (temp4)
11799         delete arg4;
11800     }
11801     return resultobj;
11802     fail:
11803     {
11804         if (temp2)
11805         delete arg2;
11806     }
11807     {
11808         if (temp3)
11809         delete arg3;
11810     }
11811     {
11812         if (temp4)
11813         delete arg4;
11814     }
11815     return NULL;
11816 }
11817
11818
11819 static PyObject *_wrap_Locale_Init2(PyObject *, PyObject *args, PyObject *kwargs) {
11820     PyObject *resultobj;
11821     wxLocale *arg1 = (wxLocale *) 0 ;
11822     int arg2 = (int) wxLANGUAGE_DEFAULT ;
11823     int arg3 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11824     bool result;
11825     PyObject * obj0 = 0 ;
11826     PyObject * obj1 = 0 ;
11827     PyObject * obj2 = 0 ;
11828     char *kwnames[] = {
11829         (char *) "self",(char *) "language",(char *) "flags", NULL
11830     };
11831
11832     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Locale_Init2",kwnames,&obj0,&obj1,&obj2)) goto fail;
11833     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11834     if (SWIG_arg_fail(1)) SWIG_fail;
11835     if (obj1) {
11836         {
11837             arg2 = (int)(SWIG_As_int(obj1));
11838             if (SWIG_arg_fail(2)) SWIG_fail;
11839         }
11840     }
11841     if (obj2) {
11842         {
11843             arg3 = (int)(SWIG_As_int(obj2));
11844             if (SWIG_arg_fail(3)) SWIG_fail;
11845         }
11846     }
11847     {
11848         PyThreadState* __tstate = wxPyBeginAllowThreads();
11849         result = (bool)wxLocale_Init2(arg1,arg2,arg3);
11850
11851         wxPyEndAllowThreads(__tstate);
11852         if (PyErr_Occurred()) SWIG_fail;
11853     }
11854     {
11855         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11856     }
11857     return resultobj;
11858     fail:
11859     return NULL;
11860 }
11861
11862
11863 static PyObject *_wrap_Locale_GetSystemLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11864     PyObject *resultobj;
11865     int result;
11866     char *kwnames[] = {
11867         NULL
11868     };
11869
11870     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemLanguage",kwnames)) goto fail;
11871     {
11872         PyThreadState* __tstate = wxPyBeginAllowThreads();
11873         result = (int)wxLocale::GetSystemLanguage();
11874
11875         wxPyEndAllowThreads(__tstate);
11876         if (PyErr_Occurred()) SWIG_fail;
11877     }
11878     {
11879         resultobj = SWIG_From_int((int)(result));
11880     }
11881     return resultobj;
11882     fail:
11883     return NULL;
11884 }
11885
11886
11887 static PyObject *_wrap_Locale_GetSystemEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11888     PyObject *resultobj;
11889     wxFontEncoding result;
11890     char *kwnames[] = {
11891         NULL
11892     };
11893
11894     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncoding",kwnames)) goto fail;
11895     {
11896         PyThreadState* __tstate = wxPyBeginAllowThreads();
11897         result = (wxFontEncoding)wxLocale::GetSystemEncoding();
11898
11899         wxPyEndAllowThreads(__tstate);
11900         if (PyErr_Occurred()) SWIG_fail;
11901     }
11902     resultobj = SWIG_From_int((result));
11903     return resultobj;
11904     fail:
11905     return NULL;
11906 }
11907
11908
11909 static PyObject *_wrap_Locale_GetSystemEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
11910     PyObject *resultobj;
11911     wxString result;
11912     char *kwnames[] = {
11913         NULL
11914     };
11915
11916     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncodingName",kwnames)) goto fail;
11917     {
11918         PyThreadState* __tstate = wxPyBeginAllowThreads();
11919         result = wxLocale::GetSystemEncodingName();
11920
11921         wxPyEndAllowThreads(__tstate);
11922         if (PyErr_Occurred()) SWIG_fail;
11923     }
11924     {
11925 #if wxUSE_UNICODE
11926         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11927 #else
11928         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11929 #endif
11930     }
11931     return resultobj;
11932     fail:
11933     return NULL;
11934 }
11935
11936
11937 static PyObject *_wrap_Locale_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11938     PyObject *resultobj;
11939     wxLocale *arg1 = (wxLocale *) 0 ;
11940     bool result;
11941     PyObject * obj0 = 0 ;
11942     char *kwnames[] = {
11943         (char *) "self", NULL
11944     };
11945
11946     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_IsOk",kwnames,&obj0)) goto fail;
11947     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11948     if (SWIG_arg_fail(1)) SWIG_fail;
11949     {
11950         PyThreadState* __tstate = wxPyBeginAllowThreads();
11951         result = (bool)((wxLocale const *)arg1)->IsOk();
11952
11953         wxPyEndAllowThreads(__tstate);
11954         if (PyErr_Occurred()) SWIG_fail;
11955     }
11956     {
11957         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11958     }
11959     return resultobj;
11960     fail:
11961     return NULL;
11962 }
11963
11964
11965 static PyObject *_wrap_Locale_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11966     PyObject *resultobj;
11967     wxLocale *arg1 = (wxLocale *) 0 ;
11968     wxString result;
11969     PyObject * obj0 = 0 ;
11970     char *kwnames[] = {
11971         (char *) "self", NULL
11972     };
11973
11974     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLocale",kwnames,&obj0)) goto fail;
11975     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11976     if (SWIG_arg_fail(1)) SWIG_fail;
11977     {
11978         PyThreadState* __tstate = wxPyBeginAllowThreads();
11979         result = ((wxLocale const *)arg1)->GetLocale();
11980
11981         wxPyEndAllowThreads(__tstate);
11982         if (PyErr_Occurred()) SWIG_fail;
11983     }
11984     {
11985 #if wxUSE_UNICODE
11986         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11987 #else
11988         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11989 #endif
11990     }
11991     return resultobj;
11992     fail:
11993     return NULL;
11994 }
11995
11996
11997 static PyObject *_wrap_Locale_GetLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11998     PyObject *resultobj;
11999     wxLocale *arg1 = (wxLocale *) 0 ;
12000     int result;
12001     PyObject * obj0 = 0 ;
12002     char *kwnames[] = {
12003         (char *) "self", NULL
12004     };
12005
12006     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguage",kwnames,&obj0)) goto fail;
12007     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12008     if (SWIG_arg_fail(1)) SWIG_fail;
12009     {
12010         PyThreadState* __tstate = wxPyBeginAllowThreads();
12011         result = (int)((wxLocale const *)arg1)->GetLanguage();
12012
12013         wxPyEndAllowThreads(__tstate);
12014         if (PyErr_Occurred()) SWIG_fail;
12015     }
12016     {
12017         resultobj = SWIG_From_int((int)(result));
12018     }
12019     return resultobj;
12020     fail:
12021     return NULL;
12022 }
12023
12024
12025 static PyObject *_wrap_Locale_GetSysName(PyObject *, PyObject *args, PyObject *kwargs) {
12026     PyObject *resultobj;
12027     wxLocale *arg1 = (wxLocale *) 0 ;
12028     wxString result;
12029     PyObject * obj0 = 0 ;
12030     char *kwnames[] = {
12031         (char *) "self", NULL
12032     };
12033
12034     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetSysName",kwnames,&obj0)) goto fail;
12035     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12036     if (SWIG_arg_fail(1)) SWIG_fail;
12037     {
12038         PyThreadState* __tstate = wxPyBeginAllowThreads();
12039         result = ((wxLocale const *)arg1)->GetSysName();
12040
12041         wxPyEndAllowThreads(__tstate);
12042         if (PyErr_Occurred()) SWIG_fail;
12043     }
12044     {
12045 #if wxUSE_UNICODE
12046         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12047 #else
12048         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12049 #endif
12050     }
12051     return resultobj;
12052     fail:
12053     return NULL;
12054 }
12055
12056
12057 static PyObject *_wrap_Locale_GetCanonicalName(PyObject *, PyObject *args, PyObject *kwargs) {
12058     PyObject *resultobj;
12059     wxLocale *arg1 = (wxLocale *) 0 ;
12060     wxString result;
12061     PyObject * obj0 = 0 ;
12062     char *kwnames[] = {
12063         (char *) "self", NULL
12064     };
12065
12066     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetCanonicalName",kwnames,&obj0)) goto fail;
12067     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12068     if (SWIG_arg_fail(1)) SWIG_fail;
12069     {
12070         PyThreadState* __tstate = wxPyBeginAllowThreads();
12071         result = ((wxLocale const *)arg1)->GetCanonicalName();
12072
12073         wxPyEndAllowThreads(__tstate);
12074         if (PyErr_Occurred()) SWIG_fail;
12075     }
12076     {
12077 #if wxUSE_UNICODE
12078         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12079 #else
12080         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12081 #endif
12082     }
12083     return resultobj;
12084     fail:
12085     return NULL;
12086 }
12087
12088
12089 static PyObject *_wrap_Locale_AddCatalogLookupPathPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
12090     PyObject *resultobj;
12091     wxString *arg1 = 0 ;
12092     bool temp1 = false ;
12093     PyObject * obj0 = 0 ;
12094     char *kwnames[] = {
12095         (char *) "prefix", NULL
12096     };
12097
12098     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddCatalogLookupPathPrefix",kwnames,&obj0)) goto fail;
12099     {
12100         arg1 = wxString_in_helper(obj0);
12101         if (arg1 == NULL) SWIG_fail;
12102         temp1 = true;
12103     }
12104     {
12105         PyThreadState* __tstate = wxPyBeginAllowThreads();
12106         wxLocale::AddCatalogLookupPathPrefix((wxString const &)*arg1);
12107
12108         wxPyEndAllowThreads(__tstate);
12109         if (PyErr_Occurred()) SWIG_fail;
12110     }
12111     Py_INCREF(Py_None); resultobj = Py_None;
12112     {
12113         if (temp1)
12114         delete arg1;
12115     }
12116     return resultobj;
12117     fail:
12118     {
12119         if (temp1)
12120         delete arg1;
12121     }
12122     return NULL;
12123 }
12124
12125
12126 static PyObject *_wrap_Locale_AddCatalog(PyObject *, PyObject *args, PyObject *kwargs) {
12127     PyObject *resultobj;
12128     wxLocale *arg1 = (wxLocale *) 0 ;
12129     wxString *arg2 = 0 ;
12130     bool result;
12131     bool temp2 = false ;
12132     PyObject * obj0 = 0 ;
12133     PyObject * obj1 = 0 ;
12134     char *kwnames[] = {
12135         (char *) "self",(char *) "szDomain", NULL
12136     };
12137
12138     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_AddCatalog",kwnames,&obj0,&obj1)) goto fail;
12139     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12140     if (SWIG_arg_fail(1)) SWIG_fail;
12141     {
12142         arg2 = wxString_in_helper(obj1);
12143         if (arg2 == NULL) SWIG_fail;
12144         temp2 = true;
12145     }
12146     {
12147         PyThreadState* __tstate = wxPyBeginAllowThreads();
12148         result = (bool)(arg1)->AddCatalog((wxString const &)*arg2);
12149
12150         wxPyEndAllowThreads(__tstate);
12151         if (PyErr_Occurred()) SWIG_fail;
12152     }
12153     {
12154         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12155     }
12156     {
12157         if (temp2)
12158         delete arg2;
12159     }
12160     return resultobj;
12161     fail:
12162     {
12163         if (temp2)
12164         delete arg2;
12165     }
12166     return NULL;
12167 }
12168
12169
12170 static PyObject *_wrap_Locale_IsLoaded(PyObject *, PyObject *args, PyObject *kwargs) {
12171     PyObject *resultobj;
12172     wxLocale *arg1 = (wxLocale *) 0 ;
12173     wxString *arg2 = 0 ;
12174     bool result;
12175     bool temp2 = false ;
12176     PyObject * obj0 = 0 ;
12177     PyObject * obj1 = 0 ;
12178     char *kwnames[] = {
12179         (char *) "self",(char *) "szDomain", NULL
12180     };
12181
12182     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_IsLoaded",kwnames,&obj0,&obj1)) goto fail;
12183     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12184     if (SWIG_arg_fail(1)) SWIG_fail;
12185     {
12186         arg2 = wxString_in_helper(obj1);
12187         if (arg2 == NULL) SWIG_fail;
12188         temp2 = true;
12189     }
12190     {
12191         PyThreadState* __tstate = wxPyBeginAllowThreads();
12192         result = (bool)((wxLocale const *)arg1)->IsLoaded((wxString const &)*arg2);
12193
12194         wxPyEndAllowThreads(__tstate);
12195         if (PyErr_Occurred()) SWIG_fail;
12196     }
12197     {
12198         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12199     }
12200     {
12201         if (temp2)
12202         delete arg2;
12203     }
12204     return resultobj;
12205     fail:
12206     {
12207         if (temp2)
12208         delete arg2;
12209     }
12210     return NULL;
12211 }
12212
12213
12214 static PyObject *_wrap_Locale_GetLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
12215     PyObject *resultobj;
12216     int arg1 ;
12217     wxLanguageInfo *result;
12218     PyObject * obj0 = 0 ;
12219     char *kwnames[] = {
12220         (char *) "lang", NULL
12221     };
12222
12223     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageInfo",kwnames,&obj0)) goto fail;
12224     {
12225         arg1 = (int)(SWIG_As_int(obj0));
12226         if (SWIG_arg_fail(1)) SWIG_fail;
12227     }
12228     {
12229         PyThreadState* __tstate = wxPyBeginAllowThreads();
12230         result = (wxLanguageInfo *)wxLocale::GetLanguageInfo(arg1);
12231
12232         wxPyEndAllowThreads(__tstate);
12233         if (PyErr_Occurred()) SWIG_fail;
12234     }
12235     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
12236     return resultobj;
12237     fail:
12238     return NULL;
12239 }
12240
12241
12242 static PyObject *_wrap_Locale_GetLanguageName(PyObject *, PyObject *args, PyObject *kwargs) {
12243     PyObject *resultobj;
12244     int arg1 ;
12245     wxString result;
12246     PyObject * obj0 = 0 ;
12247     char *kwnames[] = {
12248         (char *) "lang", NULL
12249     };
12250
12251     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageName",kwnames,&obj0)) goto fail;
12252     {
12253         arg1 = (int)(SWIG_As_int(obj0));
12254         if (SWIG_arg_fail(1)) SWIG_fail;
12255     }
12256     {
12257         PyThreadState* __tstate = wxPyBeginAllowThreads();
12258         result = wxLocale::GetLanguageName(arg1);
12259
12260         wxPyEndAllowThreads(__tstate);
12261         if (PyErr_Occurred()) SWIG_fail;
12262     }
12263     {
12264 #if wxUSE_UNICODE
12265         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12266 #else
12267         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12268 #endif
12269     }
12270     return resultobj;
12271     fail:
12272     return NULL;
12273 }
12274
12275
12276 static PyObject *_wrap_Locale_FindLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
12277     PyObject *resultobj;
12278     wxString *arg1 = 0 ;
12279     wxLanguageInfo *result;
12280     bool temp1 = false ;
12281     PyObject * obj0 = 0 ;
12282     char *kwnames[] = {
12283         (char *) "locale", NULL
12284     };
12285
12286     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_FindLanguageInfo",kwnames,&obj0)) goto fail;
12287     {
12288         arg1 = wxString_in_helper(obj0);
12289         if (arg1 == NULL) SWIG_fail;
12290         temp1 = true;
12291     }
12292     {
12293         PyThreadState* __tstate = wxPyBeginAllowThreads();
12294         result = (wxLanguageInfo *)wxLocale::FindLanguageInfo((wxString const &)*arg1);
12295
12296         wxPyEndAllowThreads(__tstate);
12297         if (PyErr_Occurred()) SWIG_fail;
12298     }
12299     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
12300     {
12301         if (temp1)
12302         delete arg1;
12303     }
12304     return resultobj;
12305     fail:
12306     {
12307         if (temp1)
12308         delete arg1;
12309     }
12310     return NULL;
12311 }
12312
12313
12314 static PyObject *_wrap_Locale_AddLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
12315     PyObject *resultobj;
12316     wxLanguageInfo *arg1 = 0 ;
12317     PyObject * obj0 = 0 ;
12318     char *kwnames[] = {
12319         (char *) "info", NULL
12320     };
12321
12322     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddLanguage",kwnames,&obj0)) goto fail;
12323     {
12324         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
12325         if (SWIG_arg_fail(1)) SWIG_fail;
12326         if (arg1 == NULL) {
12327             SWIG_null_ref("wxLanguageInfo");
12328         }
12329         if (SWIG_arg_fail(1)) SWIG_fail;
12330     }
12331     {
12332         PyThreadState* __tstate = wxPyBeginAllowThreads();
12333         wxLocale::AddLanguage((wxLanguageInfo const &)*arg1);
12334
12335         wxPyEndAllowThreads(__tstate);
12336         if (PyErr_Occurred()) SWIG_fail;
12337     }
12338     Py_INCREF(Py_None); resultobj = Py_None;
12339     return resultobj;
12340     fail:
12341     return NULL;
12342 }
12343
12344
12345 static PyObject *_wrap_Locale_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
12346     PyObject *resultobj;
12347     wxLocale *arg1 = (wxLocale *) 0 ;
12348     wxString *arg2 = 0 ;
12349     wxString const &arg3_defvalue = wxPyEmptyString ;
12350     wxString *arg3 = (wxString *) &arg3_defvalue ;
12351     wxString result;
12352     bool temp2 = false ;
12353     bool temp3 = false ;
12354     PyObject * obj0 = 0 ;
12355     PyObject * obj1 = 0 ;
12356     PyObject * obj2 = 0 ;
12357     char *kwnames[] = {
12358         (char *) "self",(char *) "szOrigString",(char *) "szDomain", NULL
12359     };
12360
12361     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Locale_GetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
12362     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12363     if (SWIG_arg_fail(1)) SWIG_fail;
12364     {
12365         arg2 = wxString_in_helper(obj1);
12366         if (arg2 == NULL) SWIG_fail;
12367         temp2 = true;
12368     }
12369     if (obj2) {
12370         {
12371             arg3 = wxString_in_helper(obj2);
12372             if (arg3 == NULL) SWIG_fail;
12373             temp3 = true;
12374         }
12375     }
12376     {
12377         PyThreadState* __tstate = wxPyBeginAllowThreads();
12378         result = ((wxLocale const *)arg1)->GetString((wxString const &)*arg2,(wxString const &)*arg3);
12379
12380         wxPyEndAllowThreads(__tstate);
12381         if (PyErr_Occurred()) SWIG_fail;
12382     }
12383     {
12384 #if wxUSE_UNICODE
12385         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12386 #else
12387         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12388 #endif
12389     }
12390     {
12391         if (temp2)
12392         delete arg2;
12393     }
12394     {
12395         if (temp3)
12396         delete arg3;
12397     }
12398     return resultobj;
12399     fail:
12400     {
12401         if (temp2)
12402         delete arg2;
12403     }
12404     {
12405         if (temp3)
12406         delete arg3;
12407     }
12408     return NULL;
12409 }
12410
12411
12412 static PyObject *_wrap_Locale_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
12413     PyObject *resultobj;
12414     wxLocale *arg1 = (wxLocale *) 0 ;
12415     wxString *result;
12416     PyObject * obj0 = 0 ;
12417     char *kwnames[] = {
12418         (char *) "self", NULL
12419     };
12420
12421     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetName",kwnames,&obj0)) goto fail;
12422     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12423     if (SWIG_arg_fail(1)) SWIG_fail;
12424     {
12425         PyThreadState* __tstate = wxPyBeginAllowThreads();
12426         {
12427             wxString const &_result_ref = ((wxLocale const *)arg1)->GetName();
12428             result = (wxString *) &_result_ref;
12429         }
12430
12431         wxPyEndAllowThreads(__tstate);
12432         if (PyErr_Occurred()) SWIG_fail;
12433     }
12434     {
12435 #if wxUSE_UNICODE
12436         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12437 #else
12438         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12439 #endif
12440     }
12441     return resultobj;
12442     fail:
12443     return NULL;
12444 }
12445
12446
12447 static PyObject * Locale_swigregister(PyObject *, PyObject *args) {
12448     PyObject *obj;
12449     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12450     SWIG_TypeClientData(SWIGTYPE_p_wxLocale, obj);
12451     Py_INCREF(obj);
12452     return Py_BuildValue((char *)"");
12453 }
12454 static PyObject *_wrap_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
12455     PyObject *resultobj;
12456     wxLocale *result;
12457     char *kwnames[] = {
12458         NULL
12459     };
12460
12461     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocale",kwnames)) goto fail;
12462     {
12463         PyThreadState* __tstate = wxPyBeginAllowThreads();
12464         result = (wxLocale *)wxGetLocale();
12465
12466         wxPyEndAllowThreads(__tstate);
12467         if (PyErr_Occurred()) SWIG_fail;
12468     }
12469     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 0);
12470     return resultobj;
12471     fail:
12472     return NULL;
12473 }
12474
12475
12476 static PyObject *_wrap_GetTranslation__SWIG_0(PyObject *, PyObject *args) {
12477     PyObject *resultobj;
12478     wxString *arg1 = 0 ;
12479     wxString result;
12480     bool temp1 = false ;
12481     PyObject * obj0 = 0 ;
12482
12483     if(!PyArg_ParseTuple(args,(char *)"O:GetTranslation",&obj0)) goto fail;
12484     {
12485         arg1 = wxString_in_helper(obj0);
12486         if (arg1 == NULL) SWIG_fail;
12487         temp1 = true;
12488     }
12489     {
12490         PyThreadState* __tstate = wxPyBeginAllowThreads();
12491         result = wxGetTranslation((wxString const &)*arg1);
12492
12493         wxPyEndAllowThreads(__tstate);
12494         if (PyErr_Occurred()) SWIG_fail;
12495     }
12496     {
12497 #if wxUSE_UNICODE
12498         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12499 #else
12500         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12501 #endif
12502     }
12503     {
12504         if (temp1)
12505         delete arg1;
12506     }
12507     return resultobj;
12508     fail:
12509     {
12510         if (temp1)
12511         delete arg1;
12512     }
12513     return NULL;
12514 }
12515
12516
12517 static PyObject *_wrap_GetTranslation__SWIG_1(PyObject *, PyObject *args) {
12518     PyObject *resultobj;
12519     wxString *arg1 = 0 ;
12520     wxString *arg2 = 0 ;
12521     size_t arg3 ;
12522     wxString result;
12523     bool temp1 = false ;
12524     bool temp2 = false ;
12525     PyObject * obj0 = 0 ;
12526     PyObject * obj1 = 0 ;
12527     PyObject * obj2 = 0 ;
12528
12529     if(!PyArg_ParseTuple(args,(char *)"OOO:GetTranslation",&obj0,&obj1,&obj2)) goto fail;
12530     {
12531         arg1 = wxString_in_helper(obj0);
12532         if (arg1 == NULL) SWIG_fail;
12533         temp1 = true;
12534     }
12535     {
12536         arg2 = wxString_in_helper(obj1);
12537         if (arg2 == NULL) SWIG_fail;
12538         temp2 = true;
12539     }
12540     {
12541         arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
12542         if (SWIG_arg_fail(3)) SWIG_fail;
12543     }
12544     {
12545         PyThreadState* __tstate = wxPyBeginAllowThreads();
12546         result = wxGetTranslation((wxString const &)*arg1,(wxString const &)*arg2,arg3);
12547
12548         wxPyEndAllowThreads(__tstate);
12549         if (PyErr_Occurred()) SWIG_fail;
12550     }
12551     {
12552 #if wxUSE_UNICODE
12553         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12554 #else
12555         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12556 #endif
12557     }
12558     {
12559         if (temp1)
12560         delete arg1;
12561     }
12562     {
12563         if (temp2)
12564         delete arg2;
12565     }
12566     return resultobj;
12567     fail:
12568     {
12569         if (temp1)
12570         delete arg1;
12571     }
12572     {
12573         if (temp2)
12574         delete arg2;
12575     }
12576     return NULL;
12577 }
12578
12579
12580 static PyObject *_wrap_GetTranslation(PyObject *self, PyObject *args) {
12581     int argc;
12582     PyObject *argv[4];
12583     int ii;
12584
12585     argc = PyObject_Length(args);
12586     for (ii = 0; (ii < argc) && (ii < 3); ii++) {
12587         argv[ii] = PyTuple_GetItem(args,ii);
12588     }
12589     if (argc == 1) {
12590         int _v;
12591         {
12592             _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12593         }
12594         if (_v) {
12595             return _wrap_GetTranslation__SWIG_0(self,args);
12596         }
12597     }
12598     if (argc == 3) {
12599         int _v;
12600         {
12601             _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12602         }
12603         if (_v) {
12604             {
12605                 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
12606             }
12607             if (_v) {
12608                 _v = SWIG_Check_unsigned_SS_long(argv[2]);
12609                 if (_v) {
12610                     return _wrap_GetTranslation__SWIG_1(self,args);
12611                 }
12612             }
12613         }
12614     }
12615
12616     PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GetTranslation'");
12617     return NULL;
12618 }
12619
12620
12621 static PyObject *_wrap_new_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
12622     PyObject *resultobj;
12623     wxEncodingConverter *result;
12624     char *kwnames[] = {
12625         NULL
12626     };
12627
12628     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EncodingConverter",kwnames)) goto fail;
12629     {
12630         PyThreadState* __tstate = wxPyBeginAllowThreads();
12631         result = (wxEncodingConverter *)new wxEncodingConverter();
12632
12633         wxPyEndAllowThreads(__tstate);
12634         if (PyErr_Occurred()) SWIG_fail;
12635     }
12636     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEncodingConverter, 1);
12637     return resultobj;
12638     fail:
12639     return NULL;
12640 }
12641
12642
12643 static PyObject *_wrap_delete_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
12644     PyObject *resultobj;
12645     wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12646     PyObject * obj0 = 0 ;
12647     char *kwnames[] = {
12648         (char *) "self", NULL
12649     };
12650
12651     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EncodingConverter",kwnames,&obj0)) goto fail;
12652     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12653     if (SWIG_arg_fail(1)) SWIG_fail;
12654     {
12655         PyThreadState* __tstate = wxPyBeginAllowThreads();
12656         delete arg1;
12657
12658         wxPyEndAllowThreads(__tstate);
12659         if (PyErr_Occurred()) SWIG_fail;
12660     }
12661     Py_INCREF(Py_None); resultobj = Py_None;
12662     return resultobj;
12663     fail:
12664     return NULL;
12665 }
12666
12667
12668 static PyObject *_wrap_EncodingConverter_Init(PyObject *, PyObject *args, PyObject *kwargs) {
12669     PyObject *resultobj;
12670     wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12671     wxFontEncoding arg2 ;
12672     wxFontEncoding arg3 ;
12673     int arg4 = (int) wxCONVERT_STRICT ;
12674     bool result;
12675     PyObject * obj0 = 0 ;
12676     PyObject * obj1 = 0 ;
12677     PyObject * obj2 = 0 ;
12678     PyObject * obj3 = 0 ;
12679     char *kwnames[] = {
12680         (char *) "self",(char *) "input_enc",(char *) "output_enc",(char *) "method", NULL
12681     };
12682
12683     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:EncodingConverter_Init",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12684     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12685     if (SWIG_arg_fail(1)) SWIG_fail;
12686     {
12687         arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12688         if (SWIG_arg_fail(2)) SWIG_fail;
12689     }
12690     {
12691         arg3 = (wxFontEncoding)(SWIG_As_int(obj2));
12692         if (SWIG_arg_fail(3)) SWIG_fail;
12693     }
12694     if (obj3) {
12695         {
12696             arg4 = (int)(SWIG_As_int(obj3));
12697             if (SWIG_arg_fail(4)) SWIG_fail;
12698         }
12699     }
12700     {
12701         PyThreadState* __tstate = wxPyBeginAllowThreads();
12702         result = (bool)(arg1)->Init((wxFontEncoding )arg2,(wxFontEncoding )arg3,arg4);
12703
12704         wxPyEndAllowThreads(__tstate);
12705         if (PyErr_Occurred()) SWIG_fail;
12706     }
12707     {
12708         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12709     }
12710     return resultobj;
12711     fail:
12712     return NULL;
12713 }
12714
12715
12716 static PyObject *_wrap_EncodingConverter_Convert(PyObject *, PyObject *args, PyObject *kwargs) {
12717     PyObject *resultobj;
12718     wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12719     wxString *arg2 = 0 ;
12720     wxString result;
12721     bool temp2 = false ;
12722     PyObject * obj0 = 0 ;
12723     PyObject * obj1 = 0 ;
12724     char *kwnames[] = {
12725         (char *) "self",(char *) "input", NULL
12726     };
12727
12728     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_Convert",kwnames,&obj0,&obj1)) goto fail;
12729     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12730     if (SWIG_arg_fail(1)) SWIG_fail;
12731     {
12732         arg2 = wxString_in_helper(obj1);
12733         if (arg2 == NULL) SWIG_fail;
12734         temp2 = true;
12735     }
12736     {
12737         PyThreadState* __tstate = wxPyBeginAllowThreads();
12738         result = (arg1)->Convert((wxString const &)*arg2);
12739
12740         wxPyEndAllowThreads(__tstate);
12741         if (PyErr_Occurred()) SWIG_fail;
12742     }
12743     {
12744 #if wxUSE_UNICODE
12745         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12746 #else
12747         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12748 #endif
12749     }
12750     {
12751         if (temp2)
12752         delete arg2;
12753     }
12754     return resultobj;
12755     fail:
12756     {
12757         if (temp2)
12758         delete arg2;
12759     }
12760     return NULL;
12761 }
12762
12763
12764 static PyObject *_wrap_EncodingConverter_GetPlatformEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12765     PyObject *resultobj;
12766     wxFontEncoding arg1 ;
12767     int arg2 = (int) wxPLATFORM_CURRENT ;
12768     wxFontEncodingArray result;
12769     PyObject * obj0 = 0 ;
12770     PyObject * obj1 = 0 ;
12771     char *kwnames[] = {
12772         (char *) "enc",(char *) "platform", NULL
12773     };
12774
12775     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EncodingConverter_GetPlatformEquivalents",kwnames,&obj0,&obj1)) goto fail;
12776     {
12777         arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12778         if (SWIG_arg_fail(1)) SWIG_fail;
12779     }
12780     if (obj1) {
12781         {
12782             arg2 = (int)(SWIG_As_int(obj1));
12783             if (SWIG_arg_fail(2)) SWIG_fail;
12784         }
12785     }
12786     {
12787         PyThreadState* __tstate = wxPyBeginAllowThreads();
12788         result = wxEncodingConverter::GetPlatformEquivalents((wxFontEncoding )arg1,arg2);
12789
12790         wxPyEndAllowThreads(__tstate);
12791         if (PyErr_Occurred()) SWIG_fail;
12792     }
12793     {
12794         resultobj = PyList_New(0);
12795         for (size_t i=0; i < (&result)->GetCount(); i++) {
12796             PyObject* number = PyInt_FromLong((&result)->Item(i));
12797             PyList_Append(resultobj, number);
12798             Py_DECREF(number);
12799         }
12800     }
12801     return resultobj;
12802     fail:
12803     return NULL;
12804 }
12805
12806
12807 static PyObject *_wrap_EncodingConverter_GetAllEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12808     PyObject *resultobj;
12809     wxFontEncoding arg1 ;
12810     wxFontEncodingArray result;
12811     PyObject * obj0 = 0 ;
12812     char *kwnames[] = {
12813         (char *) "enc", NULL
12814     };
12815
12816     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EncodingConverter_GetAllEquivalents",kwnames,&obj0)) goto fail;
12817     {
12818         arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12819         if (SWIG_arg_fail(1)) SWIG_fail;
12820     }
12821     {
12822         PyThreadState* __tstate = wxPyBeginAllowThreads();
12823         result = wxEncodingConverter::GetAllEquivalents((wxFontEncoding )arg1);
12824
12825         wxPyEndAllowThreads(__tstate);
12826         if (PyErr_Occurred()) SWIG_fail;
12827     }
12828     {
12829         resultobj = PyList_New(0);
12830         for (size_t i=0; i < (&result)->GetCount(); i++) {
12831             PyObject* number = PyInt_FromLong((&result)->Item(i));
12832             PyList_Append(resultobj, number);
12833             Py_DECREF(number);
12834         }
12835     }
12836     return resultobj;
12837     fail:
12838     return NULL;
12839 }
12840
12841
12842 static PyObject *_wrap_EncodingConverter_CanConvert(PyObject *, PyObject *args, PyObject *kwargs) {
12843     PyObject *resultobj;
12844     wxFontEncoding arg1 ;
12845     wxFontEncoding arg2 ;
12846     bool result;
12847     PyObject * obj0 = 0 ;
12848     PyObject * obj1 = 0 ;
12849     char *kwnames[] = {
12850         (char *) "encIn",(char *) "encOut", NULL
12851     };
12852
12853     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_CanConvert",kwnames,&obj0,&obj1)) goto fail;
12854     {
12855         arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12856         if (SWIG_arg_fail(1)) SWIG_fail;
12857     }
12858     {
12859         arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12860         if (SWIG_arg_fail(2)) SWIG_fail;
12861     }
12862     {
12863         PyThreadState* __tstate = wxPyBeginAllowThreads();
12864         result = (bool)wxEncodingConverter::CanConvert((wxFontEncoding )arg1,(wxFontEncoding )arg2);
12865
12866         wxPyEndAllowThreads(__tstate);
12867         if (PyErr_Occurred()) SWIG_fail;
12868     }
12869     {
12870         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12871     }
12872     return resultobj;
12873     fail:
12874     return NULL;
12875 }
12876
12877
12878 static PyObject * EncodingConverter_swigregister(PyObject *, PyObject *args) {
12879     PyObject *obj;
12880     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12881     SWIG_TypeClientData(SWIGTYPE_p_wxEncodingConverter, obj);
12882     Py_INCREF(obj);
12883     return Py_BuildValue((char *)"");
12884 }
12885 static PyObject *_wrap_delete_DC(PyObject *, PyObject *args, PyObject *kwargs) {
12886     PyObject *resultobj;
12887     wxDC *arg1 = (wxDC *) 0 ;
12888     PyObject * obj0 = 0 ;
12889     char *kwnames[] = {
12890         (char *) "self", NULL
12891     };
12892
12893     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DC",kwnames,&obj0)) goto fail;
12894     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12895     if (SWIG_arg_fail(1)) SWIG_fail;
12896     {
12897         PyThreadState* __tstate = wxPyBeginAllowThreads();
12898         delete arg1;
12899
12900         wxPyEndAllowThreads(__tstate);
12901         if (PyErr_Occurred()) SWIG_fail;
12902     }
12903     Py_INCREF(Py_None); resultobj = Py_None;
12904     return resultobj;
12905     fail:
12906     return NULL;
12907 }
12908
12909
12910 static PyObject *_wrap_DC_BeginDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12911     PyObject *resultobj;
12912     wxDC *arg1 = (wxDC *) 0 ;
12913     PyObject * obj0 = 0 ;
12914     char *kwnames[] = {
12915         (char *) "self", NULL
12916     };
12917
12918     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_BeginDrawing",kwnames,&obj0)) goto fail;
12919     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12920     if (SWIG_arg_fail(1)) SWIG_fail;
12921     {
12922         PyThreadState* __tstate = wxPyBeginAllowThreads();
12923         (arg1)->BeginDrawing();
12924
12925         wxPyEndAllowThreads(__tstate);
12926         if (PyErr_Occurred()) SWIG_fail;
12927     }
12928     Py_INCREF(Py_None); resultobj = Py_None;
12929     return resultobj;
12930     fail:
12931     return NULL;
12932 }
12933
12934
12935 static PyObject *_wrap_DC_EndDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12936     PyObject *resultobj;
12937     wxDC *arg1 = (wxDC *) 0 ;
12938     PyObject * obj0 = 0 ;
12939     char *kwnames[] = {
12940         (char *) "self", NULL
12941     };
12942
12943     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDrawing",kwnames,&obj0)) goto fail;
12944     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12945     if (SWIG_arg_fail(1)) SWIG_fail;
12946     {
12947         PyThreadState* __tstate = wxPyBeginAllowThreads();
12948         (arg1)->EndDrawing();
12949
12950         wxPyEndAllowThreads(__tstate);
12951         if (PyErr_Occurred()) SWIG_fail;
12952     }
12953     Py_INCREF(Py_None); resultobj = Py_None;
12954     return resultobj;
12955     fail:
12956     return NULL;
12957 }
12958
12959
12960 static PyObject *_wrap_DC_FloodFill(PyObject *, PyObject *args, PyObject *kwargs) {
12961     PyObject *resultobj;
12962     wxDC *arg1 = (wxDC *) 0 ;
12963     int arg2 ;
12964     int arg3 ;
12965     wxColour *arg4 = 0 ;
12966     int arg5 = (int) wxFLOOD_SURFACE ;
12967     bool result;
12968     wxColour temp4 ;
12969     PyObject * obj0 = 0 ;
12970     PyObject * obj1 = 0 ;
12971     PyObject * obj2 = 0 ;
12972     PyObject * obj3 = 0 ;
12973     PyObject * obj4 = 0 ;
12974     char *kwnames[] = {
12975         (char *) "self",(char *) "x",(char *) "y",(char *) "col",(char *) "style", NULL
12976     };
12977
12978     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_FloodFill",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12979     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12980     if (SWIG_arg_fail(1)) SWIG_fail;
12981     {
12982         arg2 = (int)(SWIG_As_int(obj1));
12983         if (SWIG_arg_fail(2)) SWIG_fail;
12984     }
12985     {
12986         arg3 = (int)(SWIG_As_int(obj2));
12987         if (SWIG_arg_fail(3)) SWIG_fail;
12988     }
12989     {
12990         arg4 = &temp4;
12991         if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
12992     }
12993     if (obj4) {
12994         {
12995             arg5 = (int)(SWIG_As_int(obj4));
12996             if (SWIG_arg_fail(5)) SWIG_fail;
12997         }
12998     }
12999     {
13000         PyThreadState* __tstate = wxPyBeginAllowThreads();
13001         result = (bool)(arg1)->FloodFill(arg2,arg3,(wxColour const &)*arg4,arg5);
13002
13003         wxPyEndAllowThreads(__tstate);
13004         if (PyErr_Occurred()) SWIG_fail;
13005     }
13006     {
13007         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13008     }
13009     return resultobj;
13010     fail:
13011     return NULL;
13012 }
13013
13014
13015 static PyObject *_wrap_DC_FloodFillPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13016     PyObject *resultobj;
13017     wxDC *arg1 = (wxDC *) 0 ;
13018     wxPoint *arg2 = 0 ;
13019     wxColour *arg3 = 0 ;
13020     int arg4 = (int) wxFLOOD_SURFACE ;
13021     bool result;
13022     wxPoint temp2 ;
13023     wxColour temp3 ;
13024     PyObject * obj0 = 0 ;
13025     PyObject * obj1 = 0 ;
13026     PyObject * obj2 = 0 ;
13027     PyObject * obj3 = 0 ;
13028     char *kwnames[] = {
13029         (char *) "self",(char *) "pt",(char *) "col",(char *) "style", NULL
13030     };
13031
13032     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_FloodFillPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13033     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13034     if (SWIG_arg_fail(1)) SWIG_fail;
13035     {
13036         arg2 = &temp2;
13037         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13038     }
13039     {
13040         arg3 = &temp3;
13041         if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
13042     }
13043     if (obj3) {
13044         {
13045             arg4 = (int)(SWIG_As_int(obj3));
13046             if (SWIG_arg_fail(4)) SWIG_fail;
13047         }
13048     }
13049     {
13050         PyThreadState* __tstate = wxPyBeginAllowThreads();
13051         result = (bool)(arg1)->FloodFill((wxPoint const &)*arg2,(wxColour const &)*arg3,arg4);
13052
13053         wxPyEndAllowThreads(__tstate);
13054         if (PyErr_Occurred()) SWIG_fail;
13055     }
13056     {
13057         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13058     }
13059     return resultobj;
13060     fail:
13061     return NULL;
13062 }
13063
13064
13065 static PyObject *_wrap_DC_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
13066     PyObject *resultobj;
13067     wxDC *arg1 = (wxDC *) 0 ;
13068     int arg2 ;
13069     int arg3 ;
13070     wxColour result;
13071     PyObject * obj0 = 0 ;
13072     PyObject * obj1 = 0 ;
13073     PyObject * obj2 = 0 ;
13074     char *kwnames[] = {
13075         (char *) "self",(char *) "x",(char *) "y", NULL
13076     };
13077
13078     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_GetPixel",kwnames,&obj0,&obj1,&obj2)) goto fail;
13079     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13080     if (SWIG_arg_fail(1)) SWIG_fail;
13081     {
13082         arg2 = (int)(SWIG_As_int(obj1));
13083         if (SWIG_arg_fail(2)) SWIG_fail;
13084     }
13085     {
13086         arg3 = (int)(SWIG_As_int(obj2));
13087         if (SWIG_arg_fail(3)) SWIG_fail;
13088     }
13089     {
13090         PyThreadState* __tstate = wxPyBeginAllowThreads();
13091         result = wxDC_GetPixel(arg1,arg2,arg3);
13092
13093         wxPyEndAllowThreads(__tstate);
13094         if (PyErr_Occurred()) SWIG_fail;
13095     }
13096     {
13097         wxColour * resultptr;
13098         resultptr = new wxColour((wxColour &)(result));
13099         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13100     }
13101     return resultobj;
13102     fail:
13103     return NULL;
13104 }
13105
13106
13107 static PyObject *_wrap_DC_GetPixelPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13108     PyObject *resultobj;
13109     wxDC *arg1 = (wxDC *) 0 ;
13110     wxPoint *arg2 = 0 ;
13111     wxColour result;
13112     wxPoint temp2 ;
13113     PyObject * obj0 = 0 ;
13114     PyObject * obj1 = 0 ;
13115     char *kwnames[] = {
13116         (char *) "self",(char *) "pt", NULL
13117     };
13118
13119     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPixelPoint",kwnames,&obj0,&obj1)) goto fail;
13120     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13121     if (SWIG_arg_fail(1)) SWIG_fail;
13122     {
13123         arg2 = &temp2;
13124         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13125     }
13126     {
13127         PyThreadState* __tstate = wxPyBeginAllowThreads();
13128         result = wxDC_GetPixelPoint(arg1,(wxPoint const &)*arg2);
13129
13130         wxPyEndAllowThreads(__tstate);
13131         if (PyErr_Occurred()) SWIG_fail;
13132     }
13133     {
13134         wxColour * resultptr;
13135         resultptr = new wxColour((wxColour &)(result));
13136         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13137     }
13138     return resultobj;
13139     fail:
13140     return NULL;
13141 }
13142
13143
13144 static PyObject *_wrap_DC_DrawLine(PyObject *, PyObject *args, PyObject *kwargs) {
13145     PyObject *resultobj;
13146     wxDC *arg1 = (wxDC *) 0 ;
13147     int arg2 ;
13148     int arg3 ;
13149     int arg4 ;
13150     int arg5 ;
13151     PyObject * obj0 = 0 ;
13152     PyObject * obj1 = 0 ;
13153     PyObject * obj2 = 0 ;
13154     PyObject * obj3 = 0 ;
13155     PyObject * obj4 = 0 ;
13156     char *kwnames[] = {
13157         (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2", NULL
13158     };
13159
13160     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13161     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13162     if (SWIG_arg_fail(1)) SWIG_fail;
13163     {
13164         arg2 = (int)(SWIG_As_int(obj1));
13165         if (SWIG_arg_fail(2)) SWIG_fail;
13166     }
13167     {
13168         arg3 = (int)(SWIG_As_int(obj2));
13169         if (SWIG_arg_fail(3)) SWIG_fail;
13170     }
13171     {
13172         arg4 = (int)(SWIG_As_int(obj3));
13173         if (SWIG_arg_fail(4)) SWIG_fail;
13174     }
13175     {
13176         arg5 = (int)(SWIG_As_int(obj4));
13177         if (SWIG_arg_fail(5)) SWIG_fail;
13178     }
13179     {
13180         PyThreadState* __tstate = wxPyBeginAllowThreads();
13181         (arg1)->DrawLine(arg2,arg3,arg4,arg5);
13182
13183         wxPyEndAllowThreads(__tstate);
13184         if (PyErr_Occurred()) SWIG_fail;
13185     }
13186     Py_INCREF(Py_None); resultobj = Py_None;
13187     return resultobj;
13188     fail:
13189     return NULL;
13190 }
13191
13192
13193 static PyObject *_wrap_DC_DrawLinePoint(PyObject *, PyObject *args, PyObject *kwargs) {
13194     PyObject *resultobj;
13195     wxDC *arg1 = (wxDC *) 0 ;
13196     wxPoint *arg2 = 0 ;
13197     wxPoint *arg3 = 0 ;
13198     wxPoint temp2 ;
13199     wxPoint temp3 ;
13200     PyObject * obj0 = 0 ;
13201     PyObject * obj1 = 0 ;
13202     PyObject * obj2 = 0 ;
13203     char *kwnames[] = {
13204         (char *) "self",(char *) "pt1",(char *) "pt2", NULL
13205     };
13206
13207     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawLinePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13208     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13209     if (SWIG_arg_fail(1)) SWIG_fail;
13210     {
13211         arg2 = &temp2;
13212         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13213     }
13214     {
13215         arg3 = &temp3;
13216         if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13217     }
13218     {
13219         PyThreadState* __tstate = wxPyBeginAllowThreads();
13220         (arg1)->DrawLine((wxPoint const &)*arg2,(wxPoint const &)*arg3);
13221
13222         wxPyEndAllowThreads(__tstate);
13223         if (PyErr_Occurred()) SWIG_fail;
13224     }
13225     Py_INCREF(Py_None); resultobj = Py_None;
13226     return resultobj;
13227     fail:
13228     return NULL;
13229 }
13230
13231
13232 static PyObject *_wrap_DC_CrossHair(PyObject *, PyObject *args, PyObject *kwargs) {
13233     PyObject *resultobj;
13234     wxDC *arg1 = (wxDC *) 0 ;
13235     int arg2 ;
13236     int arg3 ;
13237     PyObject * obj0 = 0 ;
13238     PyObject * obj1 = 0 ;
13239     PyObject * obj2 = 0 ;
13240     char *kwnames[] = {
13241         (char *) "self",(char *) "x",(char *) "y", NULL
13242     };
13243
13244     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CrossHair",kwnames,&obj0,&obj1,&obj2)) goto fail;
13245     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13246     if (SWIG_arg_fail(1)) SWIG_fail;
13247     {
13248         arg2 = (int)(SWIG_As_int(obj1));
13249         if (SWIG_arg_fail(2)) SWIG_fail;
13250     }
13251     {
13252         arg3 = (int)(SWIG_As_int(obj2));
13253         if (SWIG_arg_fail(3)) SWIG_fail;
13254     }
13255     {
13256         PyThreadState* __tstate = wxPyBeginAllowThreads();
13257         (arg1)->CrossHair(arg2,arg3);
13258
13259         wxPyEndAllowThreads(__tstate);
13260         if (PyErr_Occurred()) SWIG_fail;
13261     }
13262     Py_INCREF(Py_None); resultobj = Py_None;
13263     return resultobj;
13264     fail:
13265     return NULL;
13266 }
13267
13268
13269 static PyObject *_wrap_DC_CrossHairPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13270     PyObject *resultobj;
13271     wxDC *arg1 = (wxDC *) 0 ;
13272     wxPoint *arg2 = 0 ;
13273     wxPoint temp2 ;
13274     PyObject * obj0 = 0 ;
13275     PyObject * obj1 = 0 ;
13276     char *kwnames[] = {
13277         (char *) "self",(char *) "pt", NULL
13278     };
13279
13280     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CrossHairPoint",kwnames,&obj0,&obj1)) goto fail;
13281     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13282     if (SWIG_arg_fail(1)) SWIG_fail;
13283     {
13284         arg2 = &temp2;
13285         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13286     }
13287     {
13288         PyThreadState* __tstate = wxPyBeginAllowThreads();
13289         (arg1)->CrossHair((wxPoint const &)*arg2);
13290
13291         wxPyEndAllowThreads(__tstate);
13292         if (PyErr_Occurred()) SWIG_fail;
13293     }
13294     Py_INCREF(Py_None); resultobj = Py_None;
13295     return resultobj;
13296     fail:
13297     return NULL;
13298 }
13299
13300
13301 static PyObject *_wrap_DC_DrawArc(PyObject *, PyObject *args, PyObject *kwargs) {
13302     PyObject *resultobj;
13303     wxDC *arg1 = (wxDC *) 0 ;
13304     int arg2 ;
13305     int arg3 ;
13306     int arg4 ;
13307     int arg5 ;
13308     int arg6 ;
13309     int arg7 ;
13310     PyObject * obj0 = 0 ;
13311     PyObject * obj1 = 0 ;
13312     PyObject * obj2 = 0 ;
13313     PyObject * obj3 = 0 ;
13314     PyObject * obj4 = 0 ;
13315     PyObject * obj5 = 0 ;
13316     PyObject * obj6 = 0 ;
13317     char *kwnames[] = {
13318         (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2",(char *) "xc",(char *) "yc", NULL
13319     };
13320
13321     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13322     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13323     if (SWIG_arg_fail(1)) SWIG_fail;
13324     {
13325         arg2 = (int)(SWIG_As_int(obj1));
13326         if (SWIG_arg_fail(2)) SWIG_fail;
13327     }
13328     {
13329         arg3 = (int)(SWIG_As_int(obj2));
13330         if (SWIG_arg_fail(3)) SWIG_fail;
13331     }
13332     {
13333         arg4 = (int)(SWIG_As_int(obj3));
13334         if (SWIG_arg_fail(4)) SWIG_fail;
13335     }
13336     {
13337         arg5 = (int)(SWIG_As_int(obj4));
13338         if (SWIG_arg_fail(5)) SWIG_fail;
13339     }
13340     {
13341         arg6 = (int)(SWIG_As_int(obj5));
13342         if (SWIG_arg_fail(6)) SWIG_fail;
13343     }
13344     {
13345         arg7 = (int)(SWIG_As_int(obj6));
13346         if (SWIG_arg_fail(7)) SWIG_fail;
13347     }
13348     {
13349         PyThreadState* __tstate = wxPyBeginAllowThreads();
13350         (arg1)->DrawArc(arg2,arg3,arg4,arg5,arg6,arg7);
13351
13352         wxPyEndAllowThreads(__tstate);
13353         if (PyErr_Occurred()) SWIG_fail;
13354     }
13355     Py_INCREF(Py_None); resultobj = Py_None;
13356     return resultobj;
13357     fail:
13358     return NULL;
13359 }
13360
13361
13362 static PyObject *_wrap_DC_DrawArcPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13363     PyObject *resultobj;
13364     wxDC *arg1 = (wxDC *) 0 ;
13365     wxPoint *arg2 = 0 ;
13366     wxPoint *arg3 = 0 ;
13367     wxPoint *arg4 = 0 ;
13368     wxPoint temp2 ;
13369     wxPoint temp3 ;
13370     wxPoint temp4 ;
13371     PyObject * obj0 = 0 ;
13372     PyObject * obj1 = 0 ;
13373     PyObject * obj2 = 0 ;
13374     PyObject * obj3 = 0 ;
13375     char *kwnames[] = {
13376         (char *) "self",(char *) "pt1",(char *) "pt2",(char *) "center", NULL
13377     };
13378
13379     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawArcPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13380     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13381     if (SWIG_arg_fail(1)) SWIG_fail;
13382     {
13383         arg2 = &temp2;
13384         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13385     }
13386     {
13387         arg3 = &temp3;
13388         if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13389     }
13390     {
13391         arg4 = &temp4;
13392         if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
13393     }
13394     {
13395         PyThreadState* __tstate = wxPyBeginAllowThreads();
13396         (arg1)->DrawArc((wxPoint const &)*arg2,(wxPoint const &)*arg3,(wxPoint const &)*arg4);
13397
13398         wxPyEndAllowThreads(__tstate);
13399         if (PyErr_Occurred()) SWIG_fail;
13400     }
13401     Py_INCREF(Py_None); resultobj = Py_None;
13402     return resultobj;
13403     fail:
13404     return NULL;
13405 }
13406
13407
13408 static PyObject *_wrap_DC_DrawCheckMark(PyObject *, PyObject *args, PyObject *kwargs) {
13409     PyObject *resultobj;
13410     wxDC *arg1 = (wxDC *) 0 ;
13411     int arg2 ;
13412     int arg3 ;
13413     int arg4 ;
13414     int arg5 ;
13415     PyObject * obj0 = 0 ;
13416     PyObject * obj1 = 0 ;
13417     PyObject * obj2 = 0 ;
13418     PyObject * obj3 = 0 ;
13419     PyObject * obj4 = 0 ;
13420     char *kwnames[] = {
13421         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13422     };
13423
13424     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawCheckMark",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13425     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13426     if (SWIG_arg_fail(1)) SWIG_fail;
13427     {
13428         arg2 = (int)(SWIG_As_int(obj1));
13429         if (SWIG_arg_fail(2)) SWIG_fail;
13430     }
13431     {
13432         arg3 = (int)(SWIG_As_int(obj2));
13433         if (SWIG_arg_fail(3)) SWIG_fail;
13434     }
13435     {
13436         arg4 = (int)(SWIG_As_int(obj3));
13437         if (SWIG_arg_fail(4)) SWIG_fail;
13438     }
13439     {
13440         arg5 = (int)(SWIG_As_int(obj4));
13441         if (SWIG_arg_fail(5)) SWIG_fail;
13442     }
13443     {
13444         PyThreadState* __tstate = wxPyBeginAllowThreads();
13445         (arg1)->DrawCheckMark(arg2,arg3,arg4,arg5);
13446
13447         wxPyEndAllowThreads(__tstate);
13448         if (PyErr_Occurred()) SWIG_fail;
13449     }
13450     Py_INCREF(Py_None); resultobj = Py_None;
13451     return resultobj;
13452     fail:
13453     return NULL;
13454 }
13455
13456
13457 static PyObject *_wrap_DC_DrawCheckMarkRect(PyObject *, PyObject *args, PyObject *kwargs) {
13458     PyObject *resultobj;
13459     wxDC *arg1 = (wxDC *) 0 ;
13460     wxRect *arg2 = 0 ;
13461     wxRect temp2 ;
13462     PyObject * obj0 = 0 ;
13463     PyObject * obj1 = 0 ;
13464     char *kwnames[] = {
13465         (char *) "self",(char *) "rect", NULL
13466     };
13467
13468     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawCheckMarkRect",kwnames,&obj0,&obj1)) goto fail;
13469     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13470     if (SWIG_arg_fail(1)) SWIG_fail;
13471     {
13472         arg2 = &temp2;
13473         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13474     }
13475     {
13476         PyThreadState* __tstate = wxPyBeginAllowThreads();
13477         (arg1)->DrawCheckMark((wxRect const &)*arg2);
13478
13479         wxPyEndAllowThreads(__tstate);
13480         if (PyErr_Occurred()) SWIG_fail;
13481     }
13482     Py_INCREF(Py_None); resultobj = Py_None;
13483     return resultobj;
13484     fail:
13485     return NULL;
13486 }
13487
13488
13489 static PyObject *_wrap_DC_DrawEllipticArc(PyObject *, PyObject *args, PyObject *kwargs) {
13490     PyObject *resultobj;
13491     wxDC *arg1 = (wxDC *) 0 ;
13492     int arg2 ;
13493     int arg3 ;
13494     int arg4 ;
13495     int arg5 ;
13496     double arg6 ;
13497     double arg7 ;
13498     PyObject * obj0 = 0 ;
13499     PyObject * obj1 = 0 ;
13500     PyObject * obj2 = 0 ;
13501     PyObject * obj3 = 0 ;
13502     PyObject * obj4 = 0 ;
13503     PyObject * obj5 = 0 ;
13504     PyObject * obj6 = 0 ;
13505     char *kwnames[] = {
13506         (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h",(char *) "start",(char *) "end", NULL
13507     };
13508
13509     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawEllipticArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13510     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13511     if (SWIG_arg_fail(1)) SWIG_fail;
13512     {
13513         arg2 = (int)(SWIG_As_int(obj1));
13514         if (SWIG_arg_fail(2)) SWIG_fail;
13515     }
13516     {
13517         arg3 = (int)(SWIG_As_int(obj2));
13518         if (SWIG_arg_fail(3)) SWIG_fail;
13519     }
13520     {
13521         arg4 = (int)(SWIG_As_int(obj3));
13522         if (SWIG_arg_fail(4)) SWIG_fail;
13523     }
13524     {
13525         arg5 = (int)(SWIG_As_int(obj4));
13526         if (SWIG_arg_fail(5)) SWIG_fail;
13527     }
13528     {
13529         arg6 = (double)(SWIG_As_double(obj5));
13530         if (SWIG_arg_fail(6)) SWIG_fail;
13531     }
13532     {
13533         arg7 = (double)(SWIG_As_double(obj6));
13534         if (SWIG_arg_fail(7)) SWIG_fail;
13535     }
13536     {
13537         PyThreadState* __tstate = wxPyBeginAllowThreads();
13538         (arg1)->DrawEllipticArc(arg2,arg3,arg4,arg5,arg6,arg7);
13539
13540         wxPyEndAllowThreads(__tstate);
13541         if (PyErr_Occurred()) SWIG_fail;
13542     }
13543     Py_INCREF(Py_None); resultobj = Py_None;
13544     return resultobj;
13545     fail:
13546     return NULL;
13547 }
13548
13549
13550 static PyObject *_wrap_DC_DrawEllipticArcPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13551     PyObject *resultobj;
13552     wxDC *arg1 = (wxDC *) 0 ;
13553     wxPoint *arg2 = 0 ;
13554     wxSize *arg3 = 0 ;
13555     double arg4 ;
13556     double arg5 ;
13557     wxPoint temp2 ;
13558     wxSize temp3 ;
13559     PyObject * obj0 = 0 ;
13560     PyObject * obj1 = 0 ;
13561     PyObject * obj2 = 0 ;
13562     PyObject * obj3 = 0 ;
13563     PyObject * obj4 = 0 ;
13564     char *kwnames[] = {
13565         (char *) "self",(char *) "pt",(char *) "sz",(char *) "start",(char *) "end", NULL
13566     };
13567
13568     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipticArcPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13569     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13570     if (SWIG_arg_fail(1)) SWIG_fail;
13571     {
13572         arg2 = &temp2;
13573         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13574     }
13575     {
13576         arg3 = &temp3;
13577         if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13578     }
13579     {
13580         arg4 = (double)(SWIG_As_double(obj3));
13581         if (SWIG_arg_fail(4)) SWIG_fail;
13582     }
13583     {
13584         arg5 = (double)(SWIG_As_double(obj4));
13585         if (SWIG_arg_fail(5)) SWIG_fail;
13586     }
13587     {
13588         PyThreadState* __tstate = wxPyBeginAllowThreads();
13589         (arg1)->DrawEllipticArc((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,arg5);
13590
13591         wxPyEndAllowThreads(__tstate);
13592         if (PyErr_Occurred()) SWIG_fail;
13593     }
13594     Py_INCREF(Py_None); resultobj = Py_None;
13595     return resultobj;
13596     fail:
13597     return NULL;
13598 }
13599
13600
13601 static PyObject *_wrap_DC_DrawPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13602     PyObject *resultobj;
13603     wxDC *arg1 = (wxDC *) 0 ;
13604     int arg2 ;
13605     int arg3 ;
13606     PyObject * obj0 = 0 ;
13607     PyObject * obj1 = 0 ;
13608     PyObject * obj2 = 0 ;
13609     char *kwnames[] = {
13610         (char *) "self",(char *) "x",(char *) "y", NULL
13611     };
13612
13613     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13614     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13615     if (SWIG_arg_fail(1)) SWIG_fail;
13616     {
13617         arg2 = (int)(SWIG_As_int(obj1));
13618         if (SWIG_arg_fail(2)) SWIG_fail;
13619     }
13620     {
13621         arg3 = (int)(SWIG_As_int(obj2));
13622         if (SWIG_arg_fail(3)) SWIG_fail;
13623     }
13624     {
13625         PyThreadState* __tstate = wxPyBeginAllowThreads();
13626         (arg1)->DrawPoint(arg2,arg3);
13627
13628         wxPyEndAllowThreads(__tstate);
13629         if (PyErr_Occurred()) SWIG_fail;
13630     }
13631     Py_INCREF(Py_None); resultobj = Py_None;
13632     return resultobj;
13633     fail:
13634     return NULL;
13635 }
13636
13637
13638 static PyObject *_wrap_DC_DrawPointPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13639     PyObject *resultobj;
13640     wxDC *arg1 = (wxDC *) 0 ;
13641     wxPoint *arg2 = 0 ;
13642     wxPoint temp2 ;
13643     PyObject * obj0 = 0 ;
13644     PyObject * obj1 = 0 ;
13645     char *kwnames[] = {
13646         (char *) "self",(char *) "pt", NULL
13647     };
13648
13649     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawPointPoint",kwnames,&obj0,&obj1)) goto fail;
13650     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13651     if (SWIG_arg_fail(1)) SWIG_fail;
13652     {
13653         arg2 = &temp2;
13654         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13655     }
13656     {
13657         PyThreadState* __tstate = wxPyBeginAllowThreads();
13658         (arg1)->DrawPoint((wxPoint const &)*arg2);
13659
13660         wxPyEndAllowThreads(__tstate);
13661         if (PyErr_Occurred()) SWIG_fail;
13662     }
13663     Py_INCREF(Py_None); resultobj = Py_None;
13664     return resultobj;
13665     fail:
13666     return NULL;
13667 }
13668
13669
13670 static PyObject *_wrap_DC_DrawRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13671     PyObject *resultobj;
13672     wxDC *arg1 = (wxDC *) 0 ;
13673     int arg2 ;
13674     int arg3 ;
13675     int arg4 ;
13676     int arg5 ;
13677     PyObject * obj0 = 0 ;
13678     PyObject * obj1 = 0 ;
13679     PyObject * obj2 = 0 ;
13680     PyObject * obj3 = 0 ;
13681     PyObject * obj4 = 0 ;
13682     char *kwnames[] = {
13683         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13684     };
13685
13686     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13687     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13688     if (SWIG_arg_fail(1)) SWIG_fail;
13689     {
13690         arg2 = (int)(SWIG_As_int(obj1));
13691         if (SWIG_arg_fail(2)) SWIG_fail;
13692     }
13693     {
13694         arg3 = (int)(SWIG_As_int(obj2));
13695         if (SWIG_arg_fail(3)) SWIG_fail;
13696     }
13697     {
13698         arg4 = (int)(SWIG_As_int(obj3));
13699         if (SWIG_arg_fail(4)) SWIG_fail;
13700     }
13701     {
13702         arg5 = (int)(SWIG_As_int(obj4));
13703         if (SWIG_arg_fail(5)) SWIG_fail;
13704     }
13705     {
13706         PyThreadState* __tstate = wxPyBeginAllowThreads();
13707         (arg1)->DrawRectangle(arg2,arg3,arg4,arg5);
13708
13709         wxPyEndAllowThreads(__tstate);
13710         if (PyErr_Occurred()) SWIG_fail;
13711     }
13712     Py_INCREF(Py_None); resultobj = Py_None;
13713     return resultobj;
13714     fail:
13715     return NULL;
13716 }
13717
13718
13719 static PyObject *_wrap_DC_DrawRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13720     PyObject *resultobj;
13721     wxDC *arg1 = (wxDC *) 0 ;
13722     wxRect *arg2 = 0 ;
13723     wxRect temp2 ;
13724     PyObject * obj0 = 0 ;
13725     PyObject * obj1 = 0 ;
13726     char *kwnames[] = {
13727         (char *) "self",(char *) "rect", NULL
13728     };
13729
13730     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawRectangleRect",kwnames,&obj0,&obj1)) goto fail;
13731     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13732     if (SWIG_arg_fail(1)) SWIG_fail;
13733     {
13734         arg2 = &temp2;
13735         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13736     }
13737     {
13738         PyThreadState* __tstate = wxPyBeginAllowThreads();
13739         (arg1)->DrawRectangle((wxRect const &)*arg2);
13740
13741         wxPyEndAllowThreads(__tstate);
13742         if (PyErr_Occurred()) SWIG_fail;
13743     }
13744     Py_INCREF(Py_None); resultobj = Py_None;
13745     return resultobj;
13746     fail:
13747     return NULL;
13748 }
13749
13750
13751 static PyObject *_wrap_DC_DrawRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13752     PyObject *resultobj;
13753     wxDC *arg1 = (wxDC *) 0 ;
13754     wxPoint *arg2 = 0 ;
13755     wxSize *arg3 = 0 ;
13756     wxPoint temp2 ;
13757     wxSize temp3 ;
13758     PyObject * obj0 = 0 ;
13759     PyObject * obj1 = 0 ;
13760     PyObject * obj2 = 0 ;
13761     char *kwnames[] = {
13762         (char *) "self",(char *) "pt",(char *) "sz", NULL
13763     };
13764
13765     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRectanglePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13766     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13767     if (SWIG_arg_fail(1)) SWIG_fail;
13768     {
13769         arg2 = &temp2;
13770         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13771     }
13772     {
13773         arg3 = &temp3;
13774         if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13775     }
13776     {
13777         PyThreadState* __tstate = wxPyBeginAllowThreads();
13778         (arg1)->DrawRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3);
13779
13780         wxPyEndAllowThreads(__tstate);
13781         if (PyErr_Occurred()) SWIG_fail;
13782     }
13783     Py_INCREF(Py_None); resultobj = Py_None;
13784     return resultobj;
13785     fail:
13786     return NULL;
13787 }
13788
13789
13790 static PyObject *_wrap_DC_DrawRoundedRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13791     PyObject *resultobj;
13792     wxDC *arg1 = (wxDC *) 0 ;
13793     int arg2 ;
13794     int arg3 ;
13795     int arg4 ;
13796     int arg5 ;
13797     double arg6 ;
13798     PyObject * obj0 = 0 ;
13799     PyObject * obj1 = 0 ;
13800     PyObject * obj2 = 0 ;
13801     PyObject * obj3 = 0 ;
13802     PyObject * obj4 = 0 ;
13803     PyObject * obj5 = 0 ;
13804     char *kwnames[] = {
13805         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "radius", NULL
13806     };
13807
13808     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:DC_DrawRoundedRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
13809     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13810     if (SWIG_arg_fail(1)) SWIG_fail;
13811     {
13812         arg2 = (int)(SWIG_As_int(obj1));
13813         if (SWIG_arg_fail(2)) SWIG_fail;
13814     }
13815     {
13816         arg3 = (int)(SWIG_As_int(obj2));
13817         if (SWIG_arg_fail(3)) SWIG_fail;
13818     }
13819     {
13820         arg4 = (int)(SWIG_As_int(obj3));
13821         if (SWIG_arg_fail(4)) SWIG_fail;
13822     }
13823     {
13824         arg5 = (int)(SWIG_As_int(obj4));
13825         if (SWIG_arg_fail(5)) SWIG_fail;
13826     }
13827     {
13828         arg6 = (double)(SWIG_As_double(obj5));
13829         if (SWIG_arg_fail(6)) SWIG_fail;
13830     }
13831     {
13832         PyThreadState* __tstate = wxPyBeginAllowThreads();
13833         (arg1)->DrawRoundedRectangle(arg2,arg3,arg4,arg5,arg6);
13834
13835         wxPyEndAllowThreads(__tstate);
13836         if (PyErr_Occurred()) SWIG_fail;
13837     }
13838     Py_INCREF(Py_None); resultobj = Py_None;
13839     return resultobj;
13840     fail:
13841     return NULL;
13842 }
13843
13844
13845 static PyObject *_wrap_DC_DrawRoundedRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13846     PyObject *resultobj;
13847     wxDC *arg1 = (wxDC *) 0 ;
13848     wxRect *arg2 = 0 ;
13849     double arg3 ;
13850     wxRect temp2 ;
13851     PyObject * obj0 = 0 ;
13852     PyObject * obj1 = 0 ;
13853     PyObject * obj2 = 0 ;
13854     char *kwnames[] = {
13855         (char *) "self",(char *) "r",(char *) "radius", NULL
13856     };
13857
13858     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRoundedRectangleRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
13859     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13860     if (SWIG_arg_fail(1)) SWIG_fail;
13861     {
13862         arg2 = &temp2;
13863         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13864     }
13865     {
13866         arg3 = (double)(SWIG_As_double(obj2));
13867         if (SWIG_arg_fail(3)) SWIG_fail;
13868     }
13869     {
13870         PyThreadState* __tstate = wxPyBeginAllowThreads();
13871         (arg1)->DrawRoundedRectangle((wxRect const &)*arg2,arg3);
13872
13873         wxPyEndAllowThreads(__tstate);
13874         if (PyErr_Occurred()) SWIG_fail;
13875     }
13876     Py_INCREF(Py_None); resultobj = Py_None;
13877     return resultobj;
13878     fail:
13879     return NULL;
13880 }
13881
13882
13883 static PyObject *_wrap_DC_DrawRoundedRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13884     PyObject *resultobj;
13885     wxDC *arg1 = (wxDC *) 0 ;
13886     wxPoint *arg2 = 0 ;
13887     wxSize *arg3 = 0 ;
13888     double arg4 ;
13889     wxPoint temp2 ;
13890     wxSize temp3 ;
13891     PyObject * obj0 = 0 ;
13892     PyObject * obj1 = 0 ;
13893     PyObject * obj2 = 0 ;
13894     PyObject * obj3 = 0 ;
13895     char *kwnames[] = {
13896         (char *) "self",(char *) "pt",(char *) "sz",(char *) "radius", NULL
13897     };
13898
13899     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRoundedRectanglePointSize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13900     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13901     if (SWIG_arg_fail(1)) SWIG_fail;
13902     {
13903         arg2 = &temp2;
13904         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13905     }
13906     {
13907         arg3 = &temp3;
13908         if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13909     }
13910     {
13911         arg4 = (double)(SWIG_As_double(obj3));
13912         if (SWIG_arg_fail(4)) SWIG_fail;
13913     }
13914     {
13915         PyThreadState* __tstate = wxPyBeginAllowThreads();
13916         (arg1)->DrawRoundedRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4);
13917
13918         wxPyEndAllowThreads(__tstate);
13919         if (PyErr_Occurred()) SWIG_fail;
13920     }
13921     Py_INCREF(Py_None); resultobj = Py_None;
13922     return resultobj;
13923     fail:
13924     return NULL;
13925 }
13926
13927
13928 static PyObject *_wrap_DC_DrawCircle(PyObject *, PyObject *args, PyObject *kwargs) {
13929     PyObject *resultobj;
13930     wxDC *arg1 = (wxDC *) 0 ;
13931     int arg2 ;
13932     int arg3 ;
13933     int arg4 ;
13934     PyObject * obj0 = 0 ;
13935     PyObject * obj1 = 0 ;
13936     PyObject * obj2 = 0 ;
13937     PyObject * obj3 = 0 ;
13938     char *kwnames[] = {
13939         (char *) "self",(char *) "x",(char *) "y",(char *) "radius", NULL
13940     };
13941
13942     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawCircle",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13943     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13944     if (SWIG_arg_fail(1)) SWIG_fail;
13945     {
13946         arg2 = (int)(SWIG_As_int(obj1));
13947         if (SWIG_arg_fail(2)) SWIG_fail;
13948     }
13949     {
13950         arg3 = (int)(SWIG_As_int(obj2));
13951         if (SWIG_arg_fail(3)) SWIG_fail;
13952     }
13953     {
13954         arg4 = (int)(SWIG_As_int(obj3));
13955         if (SWIG_arg_fail(4)) SWIG_fail;
13956     }
13957     {
13958         PyThreadState* __tstate = wxPyBeginAllowThreads();
13959         (arg1)->DrawCircle(arg2,arg3,arg4);
13960
13961         wxPyEndAllowThreads(__tstate);
13962         if (PyErr_Occurred()) SWIG_fail;
13963     }
13964     Py_INCREF(Py_None); resultobj = Py_None;
13965     return resultobj;
13966     fail:
13967     return NULL;
13968 }
13969
13970
13971 static PyObject *_wrap_DC_DrawCirclePoint(PyObject *, PyObject *args, PyObject *kwargs) {
13972     PyObject *resultobj;
13973     wxDC *arg1 = (wxDC *) 0 ;
13974     wxPoint *arg2 = 0 ;
13975     int arg3 ;
13976     wxPoint temp2 ;
13977     PyObject * obj0 = 0 ;
13978     PyObject * obj1 = 0 ;
13979     PyObject * obj2 = 0 ;
13980     char *kwnames[] = {
13981         (char *) "self",(char *) "pt",(char *) "radius", NULL
13982     };
13983
13984     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawCirclePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13985     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13986     if (SWIG_arg_fail(1)) SWIG_fail;
13987     {
13988         arg2 = &temp2;
13989         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13990     }
13991     {
13992         arg3 = (int)(SWIG_As_int(obj2));
13993         if (SWIG_arg_fail(3)) SWIG_fail;
13994     }
13995     {
13996         PyThreadState* __tstate = wxPyBeginAllowThreads();
13997         (arg1)->DrawCircle((wxPoint const &)*arg2,arg3);
13998
13999         wxPyEndAllowThreads(__tstate);
14000         if (PyErr_Occurred()) SWIG_fail;
14001     }
14002     Py_INCREF(Py_None); resultobj = Py_None;
14003     return resultobj;
14004     fail:
14005     return NULL;
14006 }
14007
14008
14009 static PyObject *_wrap_DC_DrawEllipse(PyObject *, PyObject *args, PyObject *kwargs) {
14010     PyObject *resultobj;
14011     wxDC *arg1 = (wxDC *) 0 ;
14012     int arg2 ;
14013     int arg3 ;
14014     int arg4 ;
14015     int arg5 ;
14016     PyObject * obj0 = 0 ;
14017     PyObject * obj1 = 0 ;
14018     PyObject * obj2 = 0 ;
14019     PyObject * obj3 = 0 ;
14020     PyObject * obj4 = 0 ;
14021     char *kwnames[] = {
14022         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
14023     };
14024
14025     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipse",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14026     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14027     if (SWIG_arg_fail(1)) SWIG_fail;
14028     {
14029         arg2 = (int)(SWIG_As_int(obj1));
14030         if (SWIG_arg_fail(2)) SWIG_fail;
14031     }
14032     {
14033         arg3 = (int)(SWIG_As_int(obj2));
14034         if (SWIG_arg_fail(3)) SWIG_fail;
14035     }
14036     {
14037         arg4 = (int)(SWIG_As_int(obj3));
14038         if (SWIG_arg_fail(4)) SWIG_fail;
14039     }
14040     {
14041         arg5 = (int)(SWIG_As_int(obj4));
14042         if (SWIG_arg_fail(5)) SWIG_fail;
14043     }
14044     {
14045         PyThreadState* __tstate = wxPyBeginAllowThreads();
14046         (arg1)->DrawEllipse(arg2,arg3,arg4,arg5);
14047
14048         wxPyEndAllowThreads(__tstate);
14049         if (PyErr_Occurred()) SWIG_fail;
14050     }
14051     Py_INCREF(Py_None); resultobj = Py_None;
14052     return resultobj;
14053     fail:
14054     return NULL;
14055 }
14056
14057
14058 static PyObject *_wrap_DC_DrawEllipseRect(PyObject *, PyObject *args, PyObject *kwargs) {
14059     PyObject *resultobj;
14060     wxDC *arg1 = (wxDC *) 0 ;
14061     wxRect *arg2 = 0 ;
14062     wxRect temp2 ;
14063     PyObject * obj0 = 0 ;
14064     PyObject * obj1 = 0 ;
14065     char *kwnames[] = {
14066         (char *) "self",(char *) "rect", NULL
14067     };
14068
14069     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawEllipseRect",kwnames,&obj0,&obj1)) goto fail;
14070     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14071     if (SWIG_arg_fail(1)) SWIG_fail;
14072     {
14073         arg2 = &temp2;
14074         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14075     }
14076     {
14077         PyThreadState* __tstate = wxPyBeginAllowThreads();
14078         (arg1)->DrawEllipse((wxRect const &)*arg2);
14079
14080         wxPyEndAllowThreads(__tstate);
14081         if (PyErr_Occurred()) SWIG_fail;
14082     }
14083     Py_INCREF(Py_None); resultobj = Py_None;
14084     return resultobj;
14085     fail:
14086     return NULL;
14087 }
14088
14089
14090 static PyObject *_wrap_DC_DrawEllipsePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14091     PyObject *resultobj;
14092     wxDC *arg1 = (wxDC *) 0 ;
14093     wxPoint *arg2 = 0 ;
14094     wxSize *arg3 = 0 ;
14095     wxPoint temp2 ;
14096     wxSize temp3 ;
14097     PyObject * obj0 = 0 ;
14098     PyObject * obj1 = 0 ;
14099     PyObject * obj2 = 0 ;
14100     char *kwnames[] = {
14101         (char *) "self",(char *) "pt",(char *) "sz", NULL
14102     };
14103
14104     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawEllipsePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14105     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14106     if (SWIG_arg_fail(1)) SWIG_fail;
14107     {
14108         arg2 = &temp2;
14109         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14110     }
14111     {
14112         arg3 = &temp3;
14113         if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14114     }
14115     {
14116         PyThreadState* __tstate = wxPyBeginAllowThreads();
14117         (arg1)->DrawEllipse((wxPoint const &)*arg2,(wxSize const &)*arg3);
14118
14119         wxPyEndAllowThreads(__tstate);
14120         if (PyErr_Occurred()) SWIG_fail;
14121     }
14122     Py_INCREF(Py_None); resultobj = Py_None;
14123     return resultobj;
14124     fail:
14125     return NULL;
14126 }
14127
14128
14129 static PyObject *_wrap_DC_DrawIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14130     PyObject *resultobj;
14131     wxDC *arg1 = (wxDC *) 0 ;
14132     wxIcon *arg2 = 0 ;
14133     int arg3 ;
14134     int arg4 ;
14135     PyObject * obj0 = 0 ;
14136     PyObject * obj1 = 0 ;
14137     PyObject * obj2 = 0 ;
14138     PyObject * obj3 = 0 ;
14139     char *kwnames[] = {
14140         (char *) "self",(char *) "icon",(char *) "x",(char *) "y", NULL
14141     };
14142
14143     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14144     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14145     if (SWIG_arg_fail(1)) SWIG_fail;
14146     {
14147         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
14148         if (SWIG_arg_fail(2)) SWIG_fail;
14149         if (arg2 == NULL) {
14150             SWIG_null_ref("wxIcon");
14151         }
14152         if (SWIG_arg_fail(2)) SWIG_fail;
14153     }
14154     {
14155         arg3 = (int)(SWIG_As_int(obj2));
14156         if (SWIG_arg_fail(3)) SWIG_fail;
14157     }
14158     {
14159         arg4 = (int)(SWIG_As_int(obj3));
14160         if (SWIG_arg_fail(4)) SWIG_fail;
14161     }
14162     {
14163         PyThreadState* __tstate = wxPyBeginAllowThreads();
14164         (arg1)->DrawIcon((wxIcon const &)*arg2,arg3,arg4);
14165
14166         wxPyEndAllowThreads(__tstate);
14167         if (PyErr_Occurred()) SWIG_fail;
14168     }
14169     Py_INCREF(Py_None); resultobj = Py_None;
14170     return resultobj;
14171     fail:
14172     return NULL;
14173 }
14174
14175
14176 static PyObject *_wrap_DC_DrawIconPoint(PyObject *, PyObject *args, PyObject *kwargs) {
14177     PyObject *resultobj;
14178     wxDC *arg1 = (wxDC *) 0 ;
14179     wxIcon *arg2 = 0 ;
14180     wxPoint *arg3 = 0 ;
14181     wxPoint temp3 ;
14182     PyObject * obj0 = 0 ;
14183     PyObject * obj1 = 0 ;
14184     PyObject * obj2 = 0 ;
14185     char *kwnames[] = {
14186         (char *) "self",(char *) "icon",(char *) "pt", NULL
14187     };
14188
14189     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawIconPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
14190     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14191     if (SWIG_arg_fail(1)) SWIG_fail;
14192     {
14193         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
14194         if (SWIG_arg_fail(2)) SWIG_fail;
14195         if (arg2 == NULL) {
14196             SWIG_null_ref("wxIcon");
14197         }
14198         if (SWIG_arg_fail(2)) SWIG_fail;
14199     }
14200     {
14201         arg3 = &temp3;
14202         if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14203     }
14204     {
14205         PyThreadState* __tstate = wxPyBeginAllowThreads();
14206         (arg1)->DrawIcon((wxIcon const &)*arg2,(wxPoint const &)*arg3);
14207
14208         wxPyEndAllowThreads(__tstate);
14209         if (PyErr_Occurred()) SWIG_fail;
14210     }
14211     Py_INCREF(Py_None); resultobj = Py_None;
14212     return resultobj;
14213     fail:
14214     return NULL;
14215 }
14216
14217
14218 static PyObject *_wrap_DC_DrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14219     PyObject *resultobj;
14220     wxDC *arg1 = (wxDC *) 0 ;
14221     wxBitmap *arg2 = 0 ;
14222     int arg3 ;
14223     int arg4 ;
14224     bool arg5 = (bool) false ;
14225     PyObject * obj0 = 0 ;
14226     PyObject * obj1 = 0 ;
14227     PyObject * obj2 = 0 ;
14228     PyObject * obj3 = 0 ;
14229     PyObject * obj4 = 0 ;
14230     char *kwnames[] = {
14231         (char *) "self",(char *) "bmp",(char *) "x",(char *) "y",(char *) "useMask", NULL
14232     };
14233
14234     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_DrawBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14235     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14236     if (SWIG_arg_fail(1)) SWIG_fail;
14237     {
14238         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
14239         if (SWIG_arg_fail(2)) SWIG_fail;
14240         if (arg2 == NULL) {
14241             SWIG_null_ref("wxBitmap");
14242         }
14243         if (SWIG_arg_fail(2)) SWIG_fail;
14244     }
14245     {
14246         arg3 = (int)(SWIG_As_int(obj2));
14247         if (SWIG_arg_fail(3)) SWIG_fail;
14248     }
14249     {
14250         arg4 = (int)(SWIG_As_int(obj3));
14251         if (SWIG_arg_fail(4)) SWIG_fail;
14252     }
14253     if (obj4) {
14254         {
14255             arg5 = (bool)(SWIG_As_bool(obj4));
14256             if (SWIG_arg_fail(5)) SWIG_fail;
14257         }
14258     }
14259     {
14260         PyThreadState* __tstate = wxPyBeginAllowThreads();
14261         (arg1)->DrawBitmap((wxBitmap const &)*arg2,arg3,arg4,arg5);
14262
14263         wxPyEndAllowThreads(__tstate);
14264         if (PyErr_Occurred()) SWIG_fail;
14265     }
14266     Py_INCREF(Py_None); resultobj = Py_None;
14267     return resultobj;
14268     fail:
14269     return NULL;
14270 }
14271
14272
14273 static PyObject *_wrap_DC_DrawBitmapPoint(PyObject *, PyObject *args, PyObject *kwargs) {
14274     PyObject *resultobj;
14275     wxDC *arg1 = (wxDC *) 0 ;
14276     wxBitmap *arg2 = 0 ;
14277     wxPoint *arg3 = 0 ;
14278     bool arg4 = (bool) false ;
14279     wxPoint temp3 ;
14280     PyObject * obj0 = 0 ;
14281     PyObject * obj1 = 0 ;
14282     PyObject * obj2 = 0 ;
14283     PyObject * obj3 = 0 ;
14284     char *kwnames[] = {
14285         (char *) "self",(char *) "bmp",(char *) "pt",(char *) "useMask", NULL
14286     };
14287
14288     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_DrawBitmapPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14289     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14290     if (SWIG_arg_fail(1)) SWIG_fail;
14291     {
14292         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
14293         if (SWIG_arg_fail(2)) SWIG_fail;
14294         if (arg2 == NULL) {
14295             SWIG_null_ref("wxBitmap");
14296         }
14297         if (SWIG_arg_fail(2)) SWIG_fail;
14298     }
14299     {
14300         arg3 = &temp3;
14301         if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14302     }
14303     if (obj3) {
14304         {
14305             arg4 = (bool)(SWIG_As_bool(obj3));
14306             if (SWIG_arg_fail(4)) SWIG_fail;
14307         }
14308     }
14309     {
14310         PyThreadState* __tstate = wxPyBeginAllowThreads();
14311         (arg1)->DrawBitmap((wxBitmap const &)*arg2,(wxPoint const &)*arg3,arg4);
14312
14313         wxPyEndAllowThreads(__tstate);
14314         if (PyErr_Occurred()) SWIG_fail;
14315     }
14316     Py_INCREF(Py_None); resultobj = Py_None;
14317     return resultobj;
14318     fail:
14319     return NULL;
14320 }
14321
14322
14323 static PyObject *_wrap_DC_DrawText(PyObject *, PyObject *args, PyObject *kwargs) {
14324     PyObject *resultobj;
14325     wxDC *arg1 = (wxDC *) 0 ;
14326     wxString *arg2 = 0 ;
14327     int arg3 ;
14328     int arg4 ;
14329     bool temp2 = false ;
14330     PyObject * obj0 = 0 ;
14331     PyObject * obj1 = 0 ;
14332     PyObject * obj2 = 0 ;
14333     PyObject * obj3 = 0 ;
14334     char *kwnames[] = {
14335         (char *) "self",(char *) "text",(char *) "x",(char *) "y", NULL
14336     };
14337
14338     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawText",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14339     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14340     if (SWIG_arg_fail(1)) SWIG_fail;
14341     {
14342         arg2 = wxString_in_helper(obj1);
14343         if (arg2 == NULL) SWIG_fail;
14344         temp2 = true;
14345     }
14346     {
14347         arg3 = (int)(SWIG_As_int(obj2));
14348         if (SWIG_arg_fail(3)) SWIG_fail;
14349     }
14350     {
14351         arg4 = (int)(SWIG_As_int(obj3));
14352         if (SWIG_arg_fail(4)) SWIG_fail;
14353     }
14354     {
14355         PyThreadState* __tstate = wxPyBeginAllowThreads();
14356         (arg1)->DrawText((wxString const &)*arg2,arg3,arg4);
14357
14358         wxPyEndAllowThreads(__tstate);
14359         if (PyErr_Occurred()) SWIG_fail;
14360     }
14361     Py_INCREF(Py_None); resultobj = Py_None;
14362     {
14363         if (temp2)
14364         delete arg2;
14365     }
14366     return resultobj;
14367     fail:
14368     {
14369         if (temp2)
14370         delete arg2;
14371     }
14372     return NULL;
14373 }
14374
14375
14376 static PyObject *_wrap_DC_DrawTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
14377     PyObject *resultobj;
14378     wxDC *arg1 = (wxDC *) 0 ;
14379     wxString *arg2 = 0 ;
14380     wxPoint *arg3 = 0 ;
14381     bool temp2 = false ;
14382     wxPoint temp3 ;
14383     PyObject * obj0 = 0 ;
14384     PyObject * obj1 = 0 ;
14385     PyObject * obj2 = 0 ;
14386     char *kwnames[] = {
14387         (char *) "self",(char *) "text",(char *) "pt", NULL
14388     };
14389
14390     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawTextPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
14391     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14392     if (SWIG_arg_fail(1)) SWIG_fail;
14393     {
14394         arg2 = wxString_in_helper(obj1);
14395         if (arg2 == NULL) SWIG_fail;
14396         temp2 = true;
14397     }
14398     {
14399         arg3 = &temp3;
14400         if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14401     }
14402     {
14403         PyThreadState* __tstate = wxPyBeginAllowThreads();
14404         (arg1)->DrawText((wxString const &)*arg2,(wxPoint const &)*arg3);
14405
14406         wxPyEndAllowThreads(__tstate);
14407         if (PyErr_Occurred()) SWIG_fail;
14408     }
14409     Py_INCREF(Py_None); resultobj = Py_None;
14410     {
14411         if (temp2)
14412         delete arg2;
14413     }
14414     return resultobj;
14415     fail:
14416     {
14417         if (temp2)
14418         delete arg2;
14419     }
14420     return NULL;
14421 }
14422
14423
14424 static PyObject *_wrap_DC_DrawRotatedText(PyObject *, PyObject *args, PyObject *kwargs) {
14425     PyObject *resultobj;
14426     wxDC *arg1 = (wxDC *) 0 ;
14427     wxString *arg2 = 0 ;
14428     int arg3 ;
14429     int arg4 ;
14430     double arg5 ;
14431     bool temp2 = false ;
14432     PyObject * obj0 = 0 ;
14433     PyObject * obj1 = 0 ;
14434     PyObject * obj2 = 0 ;
14435     PyObject * obj3 = 0 ;
14436     PyObject * obj4 = 0 ;
14437     char *kwnames[] = {
14438         (char *) "self",(char *) "text",(char *) "x",(char *) "y",(char *) "angle", NULL
14439     };
14440
14441     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRotatedText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14442     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14443     if (SWIG_arg_fail(1)) SWIG_fail;
14444     {
14445         arg2 = wxString_in_helper(obj1);
14446         if (arg2 == NULL) SWIG_fail;
14447         temp2 = true;
14448     }
14449     {
14450         arg3 = (int)(SWIG_As_int(obj2));
14451         if (SWIG_arg_fail(3)) SWIG_fail;
14452     }
14453     {
14454         arg4 = (int)(SWIG_As_int(obj3));
14455         if (SWIG_arg_fail(4)) SWIG_fail;
14456     }
14457     {
14458         arg5 = (double)(SWIG_As_double(obj4));
14459         if (SWIG_arg_fail(5)) SWIG_fail;
14460     }
14461     {
14462         PyThreadState* __tstate = wxPyBeginAllowThreads();
14463         (arg1)->DrawRotatedText((wxString const &)*arg2,arg3,arg4,arg5);
14464
14465         wxPyEndAllowThreads(__tstate);
14466         if (PyErr_Occurred()) SWIG_fail;
14467     }
14468     Py_INCREF(Py_None); resultobj = Py_None;
14469     {
14470         if (temp2)
14471         delete arg2;
14472     }
14473     return resultobj;
14474     fail:
14475     {
14476         if (temp2)
14477         delete arg2;
14478     }
14479     return NULL;
14480 }
14481
14482
14483 static PyObject *_wrap_DC_DrawRotatedTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
14484     PyObject *resultobj;
14485     wxDC *arg1 = (wxDC *) 0 ;
14486     wxString *arg2 = 0 ;
14487     wxPoint *arg3 = 0 ;
14488     double arg4 ;
14489     bool temp2 = false ;
14490     wxPoint temp3 ;
14491     PyObject * obj0 = 0 ;
14492     PyObject * obj1 = 0 ;
14493     PyObject * obj2 = 0 ;
14494     PyObject * obj3 = 0 ;
14495     char *kwnames[] = {
14496         (char *) "self",(char *) "text",(char *) "pt",(char *) "angle", NULL
14497     };
14498
14499     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRotatedTextPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14500     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14501     if (SWIG_arg_fail(1)) SWIG_fail;
14502     {
14503         arg2 = wxString_in_helper(obj1);
14504         if (arg2 == NULL) SWIG_fail;
14505         temp2 = true;
14506     }
14507     {
14508         arg3 = &temp3;
14509         if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14510     }
14511     {
14512         arg4 = (double)(SWIG_As_double(obj3));
14513         if (SWIG_arg_fail(4)) SWIG_fail;
14514     }
14515     {
14516         PyThreadState* __tstate = wxPyBeginAllowThreads();
14517         (arg1)->DrawRotatedText((wxString const &)*arg2,(wxPoint const &)*arg3,arg4);
14518
14519         wxPyEndAllowThreads(__tstate);
14520         if (PyErr_Occurred()) SWIG_fail;
14521     }
14522     Py_INCREF(Py_None); resultobj = Py_None;
14523     {
14524         if (temp2)
14525         delete arg2;
14526     }
14527     return resultobj;
14528     fail:
14529     {
14530         if (temp2)
14531         delete arg2;
14532     }
14533     return NULL;
14534 }
14535
14536
14537 static PyObject *_wrap_DC_Blit(PyObject *, PyObject *args, PyObject *kwargs) {
14538     PyObject *resultobj;
14539     wxDC *arg1 = (wxDC *) 0 ;
14540     int arg2 ;
14541     int arg3 ;
14542     int arg4 ;
14543     int arg5 ;
14544     wxDC *arg6 = (wxDC *) 0 ;
14545     int arg7 ;
14546     int arg8 ;
14547     int arg9 = (int) wxCOPY ;
14548     bool arg10 = (bool) false ;
14549     int arg11 = (int) -1 ;
14550     int arg12 = (int) -1 ;
14551     bool result;
14552     PyObject * obj0 = 0 ;
14553     PyObject * obj1 = 0 ;
14554     PyObject * obj2 = 0 ;
14555     PyObject * obj3 = 0 ;
14556     PyObject * obj4 = 0 ;
14557     PyObject * obj5 = 0 ;
14558     PyObject * obj6 = 0 ;
14559     PyObject * obj7 = 0 ;
14560     PyObject * obj8 = 0 ;
14561     PyObject * obj9 = 0 ;
14562     PyObject * obj10 = 0 ;
14563     PyObject * obj11 = 0 ;
14564     char *kwnames[] = {
14565         (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
14566     };
14567
14568     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;
14569     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14570     if (SWIG_arg_fail(1)) SWIG_fail;
14571     {
14572         arg2 = (int)(SWIG_As_int(obj1));
14573         if (SWIG_arg_fail(2)) SWIG_fail;
14574     }
14575     {
14576         arg3 = (int)(SWIG_As_int(obj2));
14577         if (SWIG_arg_fail(3)) SWIG_fail;
14578     }
14579     {
14580         arg4 = (int)(SWIG_As_int(obj3));
14581         if (SWIG_arg_fail(4)) SWIG_fail;
14582     }
14583     {
14584         arg5 = (int)(SWIG_As_int(obj4));
14585         if (SWIG_arg_fail(5)) SWIG_fail;
14586     }
14587     SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14588     if (SWIG_arg_fail(6)) SWIG_fail;
14589     {
14590         arg7 = (int)(SWIG_As_int(obj6));
14591         if (SWIG_arg_fail(7)) SWIG_fail;
14592     }
14593     {
14594         arg8 = (int)(SWIG_As_int(obj7));
14595         if (SWIG_arg_fail(8)) SWIG_fail;
14596     }
14597     if (obj8) {
14598         {
14599             arg9 = (int)(SWIG_As_int(obj8));
14600             if (SWIG_arg_fail(9)) SWIG_fail;
14601         }
14602     }
14603     if (obj9) {
14604         {
14605             arg10 = (bool)(SWIG_As_bool(obj9));
14606             if (SWIG_arg_fail(10)) SWIG_fail;
14607         }
14608     }
14609     if (obj10) {
14610         {
14611             arg11 = (int)(SWIG_As_int(obj10));
14612             if (SWIG_arg_fail(11)) SWIG_fail;
14613         }
14614     }
14615     if (obj11) {
14616         {
14617             arg12 = (int)(SWIG_As_int(obj11));
14618             if (SWIG_arg_fail(12)) SWIG_fail;
14619         }
14620     }
14621     {
14622         PyThreadState* __tstate = wxPyBeginAllowThreads();
14623         result = (bool)(arg1)->Blit(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
14624
14625         wxPyEndAllowThreads(__tstate);
14626         if (PyErr_Occurred()) SWIG_fail;
14627     }
14628     {
14629         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14630     }
14631     return resultobj;
14632     fail:
14633     return NULL;
14634 }
14635
14636
14637 static PyObject *_wrap_DC_BlitPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14638     PyObject *resultobj;
14639     wxDC *arg1 = (wxDC *) 0 ;
14640     wxPoint *arg2 = 0 ;
14641     wxSize *arg3 = 0 ;
14642     wxDC *arg4 = (wxDC *) 0 ;
14643     wxPoint *arg5 = 0 ;
14644     int arg6 = (int) wxCOPY ;
14645     bool arg7 = (bool) false ;
14646     wxPoint const &arg8_defvalue = wxDefaultPosition ;
14647     wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
14648     bool result;
14649     wxPoint temp2 ;
14650     wxSize temp3 ;
14651     wxPoint temp5 ;
14652     wxPoint temp8 ;
14653     PyObject * obj0 = 0 ;
14654     PyObject * obj1 = 0 ;
14655     PyObject * obj2 = 0 ;
14656     PyObject * obj3 = 0 ;
14657     PyObject * obj4 = 0 ;
14658     PyObject * obj5 = 0 ;
14659     PyObject * obj6 = 0 ;
14660     PyObject * obj7 = 0 ;
14661     char *kwnames[] = {
14662         (char *) "self",(char *) "destPt",(char *) "sz",(char *) "source",(char *) "srcPt",(char *) "rop",(char *) "useMask",(char *) "srcPtMask", NULL
14663     };
14664
14665     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:DC_BlitPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
14666     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14667     if (SWIG_arg_fail(1)) SWIG_fail;
14668     {
14669         arg2 = &temp2;
14670         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14671     }
14672     {
14673         arg3 = &temp3;
14674         if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14675     }
14676     SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14677     if (SWIG_arg_fail(4)) SWIG_fail;
14678     {
14679         arg5 = &temp5;
14680         if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
14681     }
14682     if (obj5) {
14683         {
14684             arg6 = (int)(SWIG_As_int(obj5));
14685             if (SWIG_arg_fail(6)) SWIG_fail;
14686         }
14687     }
14688     if (obj6) {
14689         {
14690             arg7 = (bool)(SWIG_As_bool(obj6));
14691             if (SWIG_arg_fail(7)) SWIG_fail;
14692         }
14693     }
14694     if (obj7) {
14695         {
14696             arg8 = &temp8;
14697             if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
14698         }
14699     }
14700     {
14701         PyThreadState* __tstate = wxPyBeginAllowThreads();
14702         result = (bool)(arg1)->Blit((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,(wxPoint const &)*arg5,arg6,arg7,(wxPoint const &)*arg8);
14703
14704         wxPyEndAllowThreads(__tstate);
14705         if (PyErr_Occurred()) SWIG_fail;
14706     }
14707     {
14708         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14709     }
14710     return resultobj;
14711     fail:
14712     return NULL;
14713 }
14714
14715
14716 static PyObject *_wrap_DC_SetClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14717     PyObject *resultobj;
14718     wxDC *arg1 = (wxDC *) 0 ;
14719     int arg2 ;
14720     int arg3 ;
14721     int arg4 ;
14722     int arg5 ;
14723     PyObject * obj0 = 0 ;
14724     PyObject * obj1 = 0 ;
14725     PyObject * obj2 = 0 ;
14726     PyObject * obj3 = 0 ;
14727     PyObject * obj4 = 0 ;
14728     char *kwnames[] = {
14729         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
14730     };
14731
14732     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_SetClippingRegion",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14733     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14734     if (SWIG_arg_fail(1)) SWIG_fail;
14735     {
14736         arg2 = (int)(SWIG_As_int(obj1));
14737         if (SWIG_arg_fail(2)) SWIG_fail;
14738     }
14739     {
14740         arg3 = (int)(SWIG_As_int(obj2));
14741         if (SWIG_arg_fail(3)) SWIG_fail;
14742     }
14743     {
14744         arg4 = (int)(SWIG_As_int(obj3));
14745         if (SWIG_arg_fail(4)) SWIG_fail;
14746     }
14747     {
14748         arg5 = (int)(SWIG_As_int(obj4));
14749         if (SWIG_arg_fail(5)) SWIG_fail;
14750     }
14751     {
14752         PyThreadState* __tstate = wxPyBeginAllowThreads();
14753         (arg1)->SetClippingRegion(arg2,arg3,arg4,arg5);
14754
14755         wxPyEndAllowThreads(__tstate);
14756         if (PyErr_Occurred()) SWIG_fail;
14757     }
14758     Py_INCREF(Py_None); resultobj = Py_None;
14759     return resultobj;
14760     fail:
14761     return NULL;
14762 }
14763
14764
14765 static PyObject *_wrap_DC_SetClippingRegionPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14766     PyObject *resultobj;
14767     wxDC *arg1 = (wxDC *) 0 ;
14768     wxPoint *arg2 = 0 ;
14769     wxSize *arg3 = 0 ;
14770     wxPoint temp2 ;
14771     wxSize temp3 ;
14772     PyObject * obj0 = 0 ;
14773     PyObject * obj1 = 0 ;
14774     PyObject * obj2 = 0 ;
14775     char *kwnames[] = {
14776         (char *) "self",(char *) "pt",(char *) "sz", NULL
14777     };
14778
14779     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetClippingRegionPointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14780     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14781     if (SWIG_arg_fail(1)) SWIG_fail;
14782     {
14783         arg2 = &temp2;
14784         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14785     }
14786     {
14787         arg3 = &temp3;
14788         if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14789     }
14790     {
14791         PyThreadState* __tstate = wxPyBeginAllowThreads();
14792         (arg1)->SetClippingRegion((wxPoint const &)*arg2,(wxSize const &)*arg3);
14793
14794         wxPyEndAllowThreads(__tstate);
14795         if (PyErr_Occurred()) SWIG_fail;
14796     }
14797     Py_INCREF(Py_None); resultobj = Py_None;
14798     return resultobj;
14799     fail:
14800     return NULL;
14801 }
14802
14803
14804 static PyObject *_wrap_DC_SetClippingRegionAsRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14805     PyObject *resultobj;
14806     wxDC *arg1 = (wxDC *) 0 ;
14807     wxRegion *arg2 = 0 ;
14808     PyObject * obj0 = 0 ;
14809     PyObject * obj1 = 0 ;
14810     char *kwnames[] = {
14811         (char *) "self",(char *) "region", NULL
14812     };
14813
14814     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRegionAsRegion",kwnames,&obj0,&obj1)) goto fail;
14815     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14816     if (SWIG_arg_fail(1)) SWIG_fail;
14817     {
14818         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
14819         if (SWIG_arg_fail(2)) SWIG_fail;
14820         if (arg2 == NULL) {
14821             SWIG_null_ref("wxRegion");
14822         }
14823         if (SWIG_arg_fail(2)) SWIG_fail;
14824     }
14825     {
14826         PyThreadState* __tstate = wxPyBeginAllowThreads();
14827         (arg1)->SetClippingRegion((wxRegion const &)*arg2);
14828
14829         wxPyEndAllowThreads(__tstate);
14830         if (PyErr_Occurred()) SWIG_fail;
14831     }
14832     Py_INCREF(Py_None); resultobj = Py_None;
14833     return resultobj;
14834     fail:
14835     return NULL;
14836 }
14837
14838
14839 static PyObject *_wrap_DC_SetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
14840     PyObject *resultobj;
14841     wxDC *arg1 = (wxDC *) 0 ;
14842     wxRect *arg2 = 0 ;
14843     wxRect temp2 ;
14844     PyObject * obj0 = 0 ;
14845     PyObject * obj1 = 0 ;
14846     char *kwnames[] = {
14847         (char *) "self",(char *) "rect", NULL
14848     };
14849
14850     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRect",kwnames,&obj0,&obj1)) goto fail;
14851     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14852     if (SWIG_arg_fail(1)) SWIG_fail;
14853     {
14854         arg2 = &temp2;
14855         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14856     }
14857     {
14858         PyThreadState* __tstate = wxPyBeginAllowThreads();
14859         (arg1)->SetClippingRegion((wxRect const &)*arg2);
14860
14861         wxPyEndAllowThreads(__tstate);
14862         if (PyErr_Occurred()) SWIG_fail;
14863     }
14864     Py_INCREF(Py_None); resultobj = Py_None;
14865     return resultobj;
14866     fail:
14867     return NULL;
14868 }
14869
14870
14871 static PyObject *_wrap_DC_DrawLines(PyObject *, PyObject *args, PyObject *kwargs) {
14872     PyObject *resultobj;
14873     wxDC *arg1 = (wxDC *) 0 ;
14874     int arg2 ;
14875     wxPoint *arg3 = (wxPoint *) 0 ;
14876     int arg4 = (int) 0 ;
14877     int arg5 = (int) 0 ;
14878     PyObject * obj0 = 0 ;
14879     PyObject * obj1 = 0 ;
14880     PyObject * obj2 = 0 ;
14881     PyObject * obj3 = 0 ;
14882     char *kwnames[] = {
14883         (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset", NULL
14884     };
14885
14886     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DC_DrawLines",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14887     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14888     if (SWIG_arg_fail(1)) SWIG_fail;
14889     {
14890         arg3 = wxPoint_LIST_helper(obj1, &arg2);
14891         if (arg3 == NULL) SWIG_fail;
14892     }
14893     if (obj2) {
14894         {
14895             arg4 = (int)(SWIG_As_int(obj2));
14896             if (SWIG_arg_fail(4)) SWIG_fail;
14897         }
14898     }
14899     if (obj3) {
14900         {
14901             arg5 = (int)(SWIG_As_int(obj3));
14902             if (SWIG_arg_fail(5)) SWIG_fail;
14903         }
14904     }
14905     {
14906         PyThreadState* __tstate = wxPyBeginAllowThreads();
14907         (arg1)->DrawLines(arg2,arg3,arg4,arg5);
14908
14909         wxPyEndAllowThreads(__tstate);
14910         if (PyErr_Occurred()) SWIG_fail;
14911     }
14912     Py_INCREF(Py_None); resultobj = Py_None;
14913     {
14914         if (arg3) delete [] arg3;
14915     }
14916     return resultobj;
14917     fail:
14918     {
14919         if (arg3) delete [] arg3;
14920     }
14921     return NULL;
14922 }
14923
14924
14925 static PyObject *_wrap_DC_DrawPolygon(PyObject *, PyObject *args, PyObject *kwargs) {
14926     PyObject *resultobj;
14927     wxDC *arg1 = (wxDC *) 0 ;
14928     int arg2 ;
14929     wxPoint *arg3 = (wxPoint *) 0 ;
14930     int arg4 = (int) 0 ;
14931     int arg5 = (int) 0 ;
14932     int arg6 = (int) wxODDEVEN_RULE ;
14933     PyObject * obj0 = 0 ;
14934     PyObject * obj1 = 0 ;
14935     PyObject * obj2 = 0 ;
14936     PyObject * obj3 = 0 ;
14937     PyObject * obj4 = 0 ;
14938     char *kwnames[] = {
14939         (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset",(char *) "fillStyle", NULL
14940     };
14941
14942     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DC_DrawPolygon",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14943     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14944     if (SWIG_arg_fail(1)) SWIG_fail;
14945     {
14946         arg3 = wxPoint_LIST_helper(obj1, &arg2);
14947         if (arg3 == NULL) SWIG_fail;
14948     }
14949     if (obj2) {
14950         {
14951             arg4 = (int)(SWIG_As_int(obj2));
14952             if (SWIG_arg_fail(4)) SWIG_fail;
14953         }
14954     }
14955     if (obj3) {
14956         {
14957             arg5 = (int)(SWIG_As_int(obj3));
14958             if (SWIG_arg_fail(5)) SWIG_fail;
14959         }
14960     }
14961     if (obj4) {
14962         {
14963             arg6 = (int)(SWIG_As_int(obj4));
14964             if (SWIG_arg_fail(6)) SWIG_fail;
14965         }
14966     }
14967     {
14968         PyThreadState* __tstate = wxPyBeginAllowThreads();
14969         (arg1)->DrawPolygon(arg2,arg3,arg4,arg5,arg6);
14970
14971         wxPyEndAllowThreads(__tstate);
14972         if (PyErr_Occurred()) SWIG_fail;
14973     }
14974     Py_INCREF(Py_None); resultobj = Py_None;
14975     {
14976         if (arg3) delete [] arg3;
14977     }
14978     return resultobj;
14979     fail:
14980     {
14981         if (arg3) delete [] arg3;
14982     }
14983     return NULL;
14984 }
14985
14986
14987 static PyObject *_wrap_DC_DrawLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14988     PyObject *resultobj;
14989     wxDC *arg1 = (wxDC *) 0 ;
14990     wxString *arg2 = 0 ;
14991     wxRect *arg3 = 0 ;
14992     int arg4 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14993     int arg5 = (int) -1 ;
14994     bool temp2 = false ;
14995     wxRect temp3 ;
14996     PyObject * obj0 = 0 ;
14997     PyObject * obj1 = 0 ;
14998     PyObject * obj2 = 0 ;
14999     PyObject * obj3 = 0 ;
15000     PyObject * obj4 = 0 ;
15001     char *kwnames[] = {
15002         (char *) "self",(char *) "text",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
15003     };
15004
15005     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:DC_DrawLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
15006     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15007     if (SWIG_arg_fail(1)) SWIG_fail;
15008     {
15009         arg2 = wxString_in_helper(obj1);
15010         if (arg2 == NULL) SWIG_fail;
15011         temp2 = true;
15012     }
15013     {
15014         arg3 = &temp3;
15015         if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
15016     }
15017     if (obj3) {
15018         {
15019             arg4 = (int)(SWIG_As_int(obj3));
15020             if (SWIG_arg_fail(4)) SWIG_fail;
15021         }
15022     }
15023     if (obj4) {
15024         {
15025             arg5 = (int)(SWIG_As_int(obj4));
15026             if (SWIG_arg_fail(5)) SWIG_fail;
15027         }
15028     }
15029     {
15030         PyThreadState* __tstate = wxPyBeginAllowThreads();
15031         (arg1)->DrawLabel((wxString const &)*arg2,(wxRect const &)*arg3,arg4,arg5);
15032
15033         wxPyEndAllowThreads(__tstate);
15034         if (PyErr_Occurred()) SWIG_fail;
15035     }
15036     Py_INCREF(Py_None); resultobj = Py_None;
15037     {
15038         if (temp2)
15039         delete arg2;
15040     }
15041     return resultobj;
15042     fail:
15043     {
15044         if (temp2)
15045         delete arg2;
15046     }
15047     return NULL;
15048 }
15049
15050
15051 static PyObject *_wrap_DC_DrawImageLabel(PyObject *, PyObject *args, PyObject *kwargs) {
15052     PyObject *resultobj;
15053     wxDC *arg1 = (wxDC *) 0 ;
15054     wxString *arg2 = 0 ;
15055     wxBitmap *arg3 = 0 ;
15056     wxRect *arg4 = 0 ;
15057     int arg5 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
15058     int arg6 = (int) -1 ;
15059     wxRect result;
15060     bool temp2 = false ;
15061     wxRect temp4 ;
15062     PyObject * obj0 = 0 ;
15063     PyObject * obj1 = 0 ;
15064     PyObject * obj2 = 0 ;
15065     PyObject * obj3 = 0 ;
15066     PyObject * obj4 = 0 ;
15067     PyObject * obj5 = 0 ;
15068     char *kwnames[] = {
15069         (char *) "self",(char *) "text",(char *) "image",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
15070     };
15071
15072     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:DC_DrawImageLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
15073     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15074     if (SWIG_arg_fail(1)) SWIG_fail;
15075     {
15076         arg2 = wxString_in_helper(obj1);
15077         if (arg2 == NULL) SWIG_fail;
15078         temp2 = true;
15079     }
15080     {
15081         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
15082         if (SWIG_arg_fail(3)) SWIG_fail;
15083         if (arg3 == NULL) {
15084             SWIG_null_ref("wxBitmap");
15085         }
15086         if (SWIG_arg_fail(3)) SWIG_fail;
15087     }
15088     {
15089         arg4 = &temp4;
15090         if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
15091     }
15092     if (obj4) {
15093         {
15094             arg5 = (int)(SWIG_As_int(obj4));
15095             if (SWIG_arg_fail(5)) SWIG_fail;
15096         }
15097     }
15098     if (obj5) {
15099         {
15100             arg6 = (int)(SWIG_As_int(obj5));
15101             if (SWIG_arg_fail(6)) SWIG_fail;
15102         }
15103     }
15104     {
15105         PyThreadState* __tstate = wxPyBeginAllowThreads();
15106         result = wxDC_DrawImageLabel(arg1,(wxString const &)*arg2,(wxBitmap const &)*arg3,(wxRect const &)*arg4,arg5,arg6);
15107
15108         wxPyEndAllowThreads(__tstate);
15109         if (PyErr_Occurred()) SWIG_fail;
15110     }
15111     {
15112         wxRect * resultptr;
15113         resultptr = new wxRect((wxRect &)(result));
15114         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
15115     }
15116     {
15117         if (temp2)
15118         delete arg2;
15119     }
15120     return resultobj;
15121     fail:
15122     {
15123         if (temp2)
15124         delete arg2;
15125     }
15126     return NULL;
15127 }
15128
15129
15130 static PyObject *_wrap_DC_DrawSpline(PyObject *, PyObject *args, PyObject *kwargs) {
15131     PyObject *resultobj;
15132     wxDC *arg1 = (wxDC *) 0 ;
15133     int arg2 ;
15134     wxPoint *arg3 = (wxPoint *) 0 ;
15135     PyObject * obj0 = 0 ;
15136     PyObject * obj1 = 0 ;
15137     char *kwnames[] = {
15138         (char *) "self",(char *) "points", NULL
15139     };
15140
15141     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawSpline",kwnames,&obj0,&obj1)) goto fail;
15142     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15143     if (SWIG_arg_fail(1)) SWIG_fail;
15144     {
15145         arg3 = wxPoint_LIST_helper(obj1, &arg2);
15146         if (arg3 == NULL) SWIG_fail;
15147     }
15148     {
15149         PyThreadState* __tstate = wxPyBeginAllowThreads();
15150         (arg1)->DrawSpline(arg2,arg3);
15151
15152         wxPyEndAllowThreads(__tstate);
15153         if (PyErr_Occurred()) SWIG_fail;
15154     }
15155     Py_INCREF(Py_None); resultobj = Py_None;
15156     {
15157         if (arg3) delete [] arg3;
15158     }
15159     return resultobj;
15160     fail:
15161     {
15162         if (arg3) delete [] arg3;
15163     }
15164     return NULL;
15165 }
15166
15167
15168 static PyObject *_wrap_DC_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
15169     PyObject *resultobj;
15170     wxDC *arg1 = (wxDC *) 0 ;
15171     PyObject * obj0 = 0 ;
15172     char *kwnames[] = {
15173         (char *) "self", NULL
15174     };
15175
15176     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Clear",kwnames,&obj0)) goto fail;
15177     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15178     if (SWIG_arg_fail(1)) SWIG_fail;
15179     {
15180         PyThreadState* __tstate = wxPyBeginAllowThreads();
15181         (arg1)->Clear();
15182
15183         wxPyEndAllowThreads(__tstate);
15184         if (PyErr_Occurred()) SWIG_fail;
15185     }
15186     Py_INCREF(Py_None); resultobj = Py_None;
15187     return resultobj;
15188     fail:
15189     return NULL;
15190 }
15191
15192
15193 static PyObject *_wrap_DC_StartDoc(PyObject *, PyObject *args, PyObject *kwargs) {
15194     PyObject *resultobj;
15195     wxDC *arg1 = (wxDC *) 0 ;
15196     wxString *arg2 = 0 ;
15197     bool result;
15198     bool temp2 = false ;
15199     PyObject * obj0 = 0 ;
15200     PyObject * obj1 = 0 ;
15201     char *kwnames[] = {
15202         (char *) "self",(char *) "message", NULL
15203     };
15204
15205     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_StartDoc",kwnames,&obj0,&obj1)) goto fail;
15206     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15207     if (SWIG_arg_fail(1)) SWIG_fail;
15208     {
15209         arg2 = wxString_in_helper(obj1);
15210         if (arg2 == NULL) SWIG_fail;
15211         temp2 = true;
15212     }
15213     {
15214         PyThreadState* __tstate = wxPyBeginAllowThreads();
15215         result = (bool)(arg1)->StartDoc((wxString const &)*arg2);
15216
15217         wxPyEndAllowThreads(__tstate);
15218         if (PyErr_Occurred()) SWIG_fail;
15219     }
15220     {
15221         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15222     }
15223     {
15224         if (temp2)
15225         delete arg2;
15226     }
15227     return resultobj;
15228     fail:
15229     {
15230         if (temp2)
15231         delete arg2;
15232     }
15233     return NULL;
15234 }
15235
15236
15237 static PyObject *_wrap_DC_EndDoc(PyObject *, PyObject *args, PyObject *kwargs) {
15238     PyObject *resultobj;
15239     wxDC *arg1 = (wxDC *) 0 ;
15240     PyObject * obj0 = 0 ;
15241     char *kwnames[] = {
15242         (char *) "self", NULL
15243     };
15244
15245     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDoc",kwnames,&obj0)) goto fail;
15246     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15247     if (SWIG_arg_fail(1)) SWIG_fail;
15248     {
15249         PyThreadState* __tstate = wxPyBeginAllowThreads();
15250         (arg1)->EndDoc();
15251
15252         wxPyEndAllowThreads(__tstate);
15253         if (PyErr_Occurred()) SWIG_fail;
15254     }
15255     Py_INCREF(Py_None); resultobj = Py_None;
15256     return resultobj;
15257     fail:
15258     return NULL;
15259 }
15260
15261
15262 static PyObject *_wrap_DC_StartPage(PyObject *, PyObject *args, PyObject *kwargs) {
15263     PyObject *resultobj;
15264     wxDC *arg1 = (wxDC *) 0 ;
15265     PyObject * obj0 = 0 ;
15266     char *kwnames[] = {
15267         (char *) "self", NULL
15268     };
15269
15270     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_StartPage",kwnames,&obj0)) goto fail;
15271     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15272     if (SWIG_arg_fail(1)) SWIG_fail;
15273     {
15274         PyThreadState* __tstate = wxPyBeginAllowThreads();
15275         (arg1)->StartPage();
15276
15277         wxPyEndAllowThreads(__tstate);
15278         if (PyErr_Occurred()) SWIG_fail;
15279     }
15280     Py_INCREF(Py_None); resultobj = Py_None;
15281     return resultobj;
15282     fail:
15283     return NULL;
15284 }
15285
15286
15287 static PyObject *_wrap_DC_EndPage(PyObject *, PyObject *args, PyObject *kwargs) {
15288     PyObject *resultobj;
15289     wxDC *arg1 = (wxDC *) 0 ;
15290     PyObject * obj0 = 0 ;
15291     char *kwnames[] = {
15292         (char *) "self", NULL
15293     };
15294
15295     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndPage",kwnames,&obj0)) goto fail;
15296     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15297     if (SWIG_arg_fail(1)) SWIG_fail;
15298     {
15299         PyThreadState* __tstate = wxPyBeginAllowThreads();
15300         (arg1)->EndPage();
15301
15302         wxPyEndAllowThreads(__tstate);
15303         if (PyErr_Occurred()) SWIG_fail;
15304     }
15305     Py_INCREF(Py_None); resultobj = Py_None;
15306     return resultobj;
15307     fail:
15308     return NULL;
15309 }
15310
15311
15312 static PyObject *_wrap_DC_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
15313     PyObject *resultobj;
15314     wxDC *arg1 = (wxDC *) 0 ;
15315     wxFont *arg2 = 0 ;
15316     PyObject * obj0 = 0 ;
15317     PyObject * obj1 = 0 ;
15318     char *kwnames[] = {
15319         (char *) "self",(char *) "font", NULL
15320     };
15321
15322     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetFont",kwnames,&obj0,&obj1)) goto fail;
15323     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15324     if (SWIG_arg_fail(1)) SWIG_fail;
15325     {
15326         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15327         if (SWIG_arg_fail(2)) SWIG_fail;
15328         if (arg2 == NULL) {
15329             SWIG_null_ref("wxFont");
15330         }
15331         if (SWIG_arg_fail(2)) SWIG_fail;
15332     }
15333     {
15334         PyThreadState* __tstate = wxPyBeginAllowThreads();
15335         (arg1)->SetFont((wxFont const &)*arg2);
15336
15337         wxPyEndAllowThreads(__tstate);
15338         if (PyErr_Occurred()) SWIG_fail;
15339     }
15340     Py_INCREF(Py_None); resultobj = Py_None;
15341     return resultobj;
15342     fail:
15343     return NULL;
15344 }
15345
15346
15347 static PyObject *_wrap_DC_SetPen(PyObject *, PyObject *args, PyObject *kwargs) {
15348     PyObject *resultobj;
15349     wxDC *arg1 = (wxDC *) 0 ;
15350     wxPen *arg2 = 0 ;
15351     PyObject * obj0 = 0 ;
15352     PyObject * obj1 = 0 ;
15353     char *kwnames[] = {
15354         (char *) "self",(char *) "pen", NULL
15355     };
15356
15357     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPen",kwnames,&obj0,&obj1)) goto fail;
15358     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15359     if (SWIG_arg_fail(1)) SWIG_fail;
15360     {
15361         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
15362         if (SWIG_arg_fail(2)) SWIG_fail;
15363         if (arg2 == NULL) {
15364             SWIG_null_ref("wxPen");
15365         }
15366         if (SWIG_arg_fail(2)) SWIG_fail;
15367     }
15368     {
15369         PyThreadState* __tstate = wxPyBeginAllowThreads();
15370         (arg1)->SetPen((wxPen const &)*arg2);
15371
15372         wxPyEndAllowThreads(__tstate);
15373         if (PyErr_Occurred()) SWIG_fail;
15374     }
15375     Py_INCREF(Py_None); resultobj = Py_None;
15376     return resultobj;
15377     fail:
15378     return NULL;
15379 }
15380
15381
15382 static PyObject *_wrap_DC_SetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
15383     PyObject *resultobj;
15384     wxDC *arg1 = (wxDC *) 0 ;
15385     wxBrush *arg2 = 0 ;
15386     PyObject * obj0 = 0 ;
15387     PyObject * obj1 = 0 ;
15388     char *kwnames[] = {
15389         (char *) "self",(char *) "brush", NULL
15390     };
15391
15392     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBrush",kwnames,&obj0,&obj1)) goto fail;
15393     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15394     if (SWIG_arg_fail(1)) SWIG_fail;
15395     {
15396         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
15397         if (SWIG_arg_fail(2)) SWIG_fail;
15398         if (arg2 == NULL) {
15399             SWIG_null_ref("wxBrush");
15400         }
15401         if (SWIG_arg_fail(2)) SWIG_fail;
15402     }
15403     {
15404         PyThreadState* __tstate = wxPyBeginAllowThreads();
15405         (arg1)->SetBrush((wxBrush const &)*arg2);
15406
15407         wxPyEndAllowThreads(__tstate);
15408         if (PyErr_Occurred()) SWIG_fail;
15409     }
15410     Py_INCREF(Py_None); resultobj = Py_None;
15411     return resultobj;
15412     fail:
15413     return NULL;
15414 }
15415
15416
15417 static PyObject *_wrap_DC_SetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15418     PyObject *resultobj;
15419     wxDC *arg1 = (wxDC *) 0 ;
15420     wxBrush *arg2 = 0 ;
15421     PyObject * obj0 = 0 ;
15422     PyObject * obj1 = 0 ;
15423     char *kwnames[] = {
15424         (char *) "self",(char *) "brush", NULL
15425     };
15426
15427     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackground",kwnames,&obj0,&obj1)) goto fail;
15428     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15429     if (SWIG_arg_fail(1)) SWIG_fail;
15430     {
15431         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
15432         if (SWIG_arg_fail(2)) SWIG_fail;
15433         if (arg2 == NULL) {
15434             SWIG_null_ref("wxBrush");
15435         }
15436         if (SWIG_arg_fail(2)) SWIG_fail;
15437     }
15438     {
15439         PyThreadState* __tstate = wxPyBeginAllowThreads();
15440         (arg1)->SetBackground((wxBrush const &)*arg2);
15441
15442         wxPyEndAllowThreads(__tstate);
15443         if (PyErr_Occurred()) SWIG_fail;
15444     }
15445     Py_INCREF(Py_None); resultobj = Py_None;
15446     return resultobj;
15447     fail:
15448     return NULL;
15449 }
15450
15451
15452 static PyObject *_wrap_DC_SetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
15453     PyObject *resultobj;
15454     wxDC *arg1 = (wxDC *) 0 ;
15455     int arg2 ;
15456     PyObject * obj0 = 0 ;
15457     PyObject * obj1 = 0 ;
15458     char *kwnames[] = {
15459         (char *) "self",(char *) "mode", NULL
15460     };
15461
15462     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackgroundMode",kwnames,&obj0,&obj1)) goto fail;
15463     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15464     if (SWIG_arg_fail(1)) SWIG_fail;
15465     {
15466         arg2 = (int)(SWIG_As_int(obj1));
15467         if (SWIG_arg_fail(2)) SWIG_fail;
15468     }
15469     {
15470         PyThreadState* __tstate = wxPyBeginAllowThreads();
15471         (arg1)->SetBackgroundMode(arg2);
15472
15473         wxPyEndAllowThreads(__tstate);
15474         if (PyErr_Occurred()) SWIG_fail;
15475     }
15476     Py_INCREF(Py_None); resultobj = Py_None;
15477     return resultobj;
15478     fail:
15479     return NULL;
15480 }
15481
15482
15483 static PyObject *_wrap_DC_SetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
15484     PyObject *resultobj;
15485     wxDC *arg1 = (wxDC *) 0 ;
15486     wxPalette *arg2 = 0 ;
15487     PyObject * obj0 = 0 ;
15488     PyObject * obj1 = 0 ;
15489     char *kwnames[] = {
15490         (char *) "self",(char *) "palette", NULL
15491     };
15492
15493     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPalette",kwnames,&obj0,&obj1)) 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         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
15498         if (SWIG_arg_fail(2)) SWIG_fail;
15499         if (arg2 == NULL) {
15500             SWIG_null_ref("wxPalette");
15501         }
15502         if (SWIG_arg_fail(2)) SWIG_fail;
15503     }
15504     {
15505         PyThreadState* __tstate = wxPyBeginAllowThreads();
15506         (arg1)->SetPalette((wxPalette const &)*arg2);
15507
15508         wxPyEndAllowThreads(__tstate);
15509         if (PyErr_Occurred()) SWIG_fail;
15510     }
15511     Py_INCREF(Py_None); resultobj = Py_None;
15512     return resultobj;
15513     fail:
15514     return NULL;
15515 }
15516
15517
15518 static PyObject *_wrap_DC_DestroyClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
15519     PyObject *resultobj;
15520     wxDC *arg1 = (wxDC *) 0 ;
15521     PyObject * obj0 = 0 ;
15522     char *kwnames[] = {
15523         (char *) "self", NULL
15524     };
15525
15526     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_DestroyClippingRegion",kwnames,&obj0)) goto fail;
15527     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15528     if (SWIG_arg_fail(1)) SWIG_fail;
15529     {
15530         PyThreadState* __tstate = wxPyBeginAllowThreads();
15531         (arg1)->DestroyClippingRegion();
15532
15533         wxPyEndAllowThreads(__tstate);
15534         if (PyErr_Occurred()) SWIG_fail;
15535     }
15536     Py_INCREF(Py_None); resultobj = Py_None;
15537     return resultobj;
15538     fail:
15539     return NULL;
15540 }
15541
15542
15543 static PyObject *_wrap_DC_GetClippingBox(PyObject *, PyObject *args, PyObject *kwargs) {
15544     PyObject *resultobj;
15545     wxDC *arg1 = (wxDC *) 0 ;
15546     int *arg2 = (int *) 0 ;
15547     int *arg3 = (int *) 0 ;
15548     int *arg4 = (int *) 0 ;
15549     int *arg5 = (int *) 0 ;
15550     int temp2 ;
15551     int res2 = 0 ;
15552     int temp3 ;
15553     int res3 = 0 ;
15554     int temp4 ;
15555     int res4 = 0 ;
15556     int temp5 ;
15557     int res5 = 0 ;
15558     PyObject * obj0 = 0 ;
15559     char *kwnames[] = {
15560         (char *) "self", NULL
15561     };
15562
15563     arg2 = &temp2; res2 = SWIG_NEWOBJ;
15564     arg3 = &temp3; res3 = SWIG_NEWOBJ;
15565     arg4 = &temp4; res4 = SWIG_NEWOBJ;
15566     arg5 = &temp5; res5 = SWIG_NEWOBJ;
15567     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingBox",kwnames,&obj0)) goto fail;
15568     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15569     if (SWIG_arg_fail(1)) SWIG_fail;
15570     {
15571         PyThreadState* __tstate = wxPyBeginAllowThreads();
15572         ((wxDC const *)arg1)->GetClippingBox(arg2,arg3,arg4,arg5);
15573
15574         wxPyEndAllowThreads(__tstate);
15575         if (PyErr_Occurred()) SWIG_fail;
15576     }
15577     Py_INCREF(Py_None); resultobj = Py_None;
15578     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15579     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15580     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15581     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15582     resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15583     SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15584     resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15585     SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15586     return resultobj;
15587     fail:
15588     return NULL;
15589 }
15590
15591
15592 static PyObject *_wrap_DC_GetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
15593     PyObject *resultobj;
15594     wxDC *arg1 = (wxDC *) 0 ;
15595     wxRect result;
15596     PyObject * obj0 = 0 ;
15597     char *kwnames[] = {
15598         (char *) "self", NULL
15599     };
15600
15601     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingRect",kwnames,&obj0)) goto fail;
15602     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15603     if (SWIG_arg_fail(1)) SWIG_fail;
15604     {
15605         PyThreadState* __tstate = wxPyBeginAllowThreads();
15606         result = wxDC_GetClippingRect(arg1);
15607
15608         wxPyEndAllowThreads(__tstate);
15609         if (PyErr_Occurred()) SWIG_fail;
15610     }
15611     {
15612         wxRect * resultptr;
15613         resultptr = new wxRect((wxRect &)(result));
15614         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
15615     }
15616     return resultobj;
15617     fail:
15618     return NULL;
15619 }
15620
15621
15622 static PyObject *_wrap_DC_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
15623     PyObject *resultobj;
15624     wxDC *arg1 = (wxDC *) 0 ;
15625     int result;
15626     PyObject * obj0 = 0 ;
15627     char *kwnames[] = {
15628         (char *) "self", NULL
15629     };
15630
15631     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharHeight",kwnames,&obj0)) goto fail;
15632     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15633     if (SWIG_arg_fail(1)) SWIG_fail;
15634     {
15635         PyThreadState* __tstate = wxPyBeginAllowThreads();
15636         result = (int)((wxDC const *)arg1)->GetCharHeight();
15637
15638         wxPyEndAllowThreads(__tstate);
15639         if (PyErr_Occurred()) SWIG_fail;
15640     }
15641     {
15642         resultobj = SWIG_From_int((int)(result));
15643     }
15644     return resultobj;
15645     fail:
15646     return NULL;
15647 }
15648
15649
15650 static PyObject *_wrap_DC_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
15651     PyObject *resultobj;
15652     wxDC *arg1 = (wxDC *) 0 ;
15653     int result;
15654     PyObject * obj0 = 0 ;
15655     char *kwnames[] = {
15656         (char *) "self", NULL
15657     };
15658
15659     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharWidth",kwnames,&obj0)) goto fail;
15660     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15661     if (SWIG_arg_fail(1)) SWIG_fail;
15662     {
15663         PyThreadState* __tstate = wxPyBeginAllowThreads();
15664         result = (int)((wxDC const *)arg1)->GetCharWidth();
15665
15666         wxPyEndAllowThreads(__tstate);
15667         if (PyErr_Occurred()) SWIG_fail;
15668     }
15669     {
15670         resultobj = SWIG_From_int((int)(result));
15671     }
15672     return resultobj;
15673     fail:
15674     return NULL;
15675 }
15676
15677
15678 static PyObject *_wrap_DC_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15679     PyObject *resultobj;
15680     wxDC *arg1 = (wxDC *) 0 ;
15681     wxString *arg2 = 0 ;
15682     int *arg3 = (int *) 0 ;
15683     int *arg4 = (int *) 0 ;
15684     bool temp2 = false ;
15685     int temp3 ;
15686     int res3 = 0 ;
15687     int temp4 ;
15688     int res4 = 0 ;
15689     PyObject * obj0 = 0 ;
15690     PyObject * obj1 = 0 ;
15691     char *kwnames[] = {
15692         (char *) "self",(char *) "string", NULL
15693     };
15694
15695     arg3 = &temp3; res3 = SWIG_NEWOBJ;
15696     arg4 = &temp4; res4 = SWIG_NEWOBJ;
15697     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
15698     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15699     if (SWIG_arg_fail(1)) SWIG_fail;
15700     {
15701         arg2 = wxString_in_helper(obj1);
15702         if (arg2 == NULL) SWIG_fail;
15703         temp2 = true;
15704     }
15705     {
15706         PyThreadState* __tstate = wxPyBeginAllowThreads();
15707         (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
15708
15709         wxPyEndAllowThreads(__tstate);
15710         if (PyErr_Occurred()) SWIG_fail;
15711     }
15712     Py_INCREF(Py_None); resultobj = Py_None;
15713     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15714     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15715     resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15716     SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15717     {
15718         if (temp2)
15719         delete arg2;
15720     }
15721     return resultobj;
15722     fail:
15723     {
15724         if (temp2)
15725         delete arg2;
15726     }
15727     return NULL;
15728 }
15729
15730
15731 static PyObject *_wrap_DC_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15732     PyObject *resultobj;
15733     wxDC *arg1 = (wxDC *) 0 ;
15734     wxString *arg2 = 0 ;
15735     int *arg3 = (int *) 0 ;
15736     int *arg4 = (int *) 0 ;
15737     int *arg5 = (int *) 0 ;
15738     int *arg6 = (int *) 0 ;
15739     wxFont *arg7 = (wxFont *) NULL ;
15740     bool temp2 = false ;
15741     int temp3 ;
15742     int res3 = 0 ;
15743     int temp4 ;
15744     int res4 = 0 ;
15745     int temp5 ;
15746     int res5 = 0 ;
15747     int temp6 ;
15748     int res6 = 0 ;
15749     PyObject * obj0 = 0 ;
15750     PyObject * obj1 = 0 ;
15751     PyObject * obj2 = 0 ;
15752     char *kwnames[] = {
15753         (char *) "self",(char *) "string",(char *) "font", NULL
15754     };
15755
15756     arg3 = &temp3; res3 = SWIG_NEWOBJ;
15757     arg4 = &temp4; res4 = SWIG_NEWOBJ;
15758     arg5 = &temp5; res5 = SWIG_NEWOBJ;
15759     arg6 = &temp6; res6 = SWIG_NEWOBJ;
15760     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15761     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15762     if (SWIG_arg_fail(1)) SWIG_fail;
15763     {
15764         arg2 = wxString_in_helper(obj1);
15765         if (arg2 == NULL) SWIG_fail;
15766         temp2 = true;
15767     }
15768     if (obj2) {
15769         SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15770         if (SWIG_arg_fail(7)) SWIG_fail;
15771     }
15772     {
15773         PyThreadState* __tstate = wxPyBeginAllowThreads();
15774         (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
15775
15776         wxPyEndAllowThreads(__tstate);
15777         if (PyErr_Occurred()) SWIG_fail;
15778     }
15779     Py_INCREF(Py_None); resultobj = Py_None;
15780     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15781     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15782     resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15783     SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15784     resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15785     SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15786     resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
15787     SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
15788     {
15789         if (temp2)
15790         delete arg2;
15791     }
15792     return resultobj;
15793     fail:
15794     {
15795         if (temp2)
15796         delete arg2;
15797     }
15798     return NULL;
15799 }
15800
15801
15802 static PyObject *_wrap_DC_GetMultiLineTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15803     PyObject *resultobj;
15804     wxDC *arg1 = (wxDC *) 0 ;
15805     wxString *arg2 = 0 ;
15806     int *arg3 = (int *) 0 ;
15807     int *arg4 = (int *) 0 ;
15808     int *arg5 = (int *) 0 ;
15809     wxFont *arg6 = (wxFont *) NULL ;
15810     bool temp2 = false ;
15811     int temp3 ;
15812     int res3 = 0 ;
15813     int temp4 ;
15814     int res4 = 0 ;
15815     int temp5 ;
15816     int res5 = 0 ;
15817     PyObject * obj0 = 0 ;
15818     PyObject * obj1 = 0 ;
15819     PyObject * obj2 = 0 ;
15820     char *kwnames[] = {
15821         (char *) "self",(char *) "text",(char *) "font", NULL
15822     };
15823
15824     arg3 = &temp3; res3 = SWIG_NEWOBJ;
15825     arg4 = &temp4; res4 = SWIG_NEWOBJ;
15826     arg5 = &temp5; res5 = SWIG_NEWOBJ;
15827     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetMultiLineTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15828     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15829     if (SWIG_arg_fail(1)) SWIG_fail;
15830     {
15831         arg2 = wxString_in_helper(obj1);
15832         if (arg2 == NULL) SWIG_fail;
15833         temp2 = true;
15834     }
15835     if (obj2) {
15836         SWIG_Python_ConvertPtr(obj2, (void **)&arg6, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15837         if (SWIG_arg_fail(6)) SWIG_fail;
15838     }
15839     {
15840         PyThreadState* __tstate = wxPyBeginAllowThreads();
15841         (arg1)->GetMultiLineTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6);
15842
15843         wxPyEndAllowThreads(__tstate);
15844         if (PyErr_Occurred()) SWIG_fail;
15845     }
15846     Py_INCREF(Py_None); resultobj = Py_None;
15847     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15848     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15849     resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15850     SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15851     resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15852     SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15853     {
15854         if (temp2)
15855         delete arg2;
15856     }
15857     return resultobj;
15858     fail:
15859     {
15860         if (temp2)
15861         delete arg2;
15862     }
15863     return NULL;
15864 }
15865
15866
15867 static PyObject *_wrap_DC_GetPartialTextExtents(PyObject *, PyObject *args, PyObject *kwargs) {
15868     PyObject *resultobj;
15869     wxDC *arg1 = (wxDC *) 0 ;
15870     wxString *arg2 = 0 ;
15871     wxArrayInt result;
15872     bool temp2 = false ;
15873     PyObject * obj0 = 0 ;
15874     PyObject * obj1 = 0 ;
15875     char *kwnames[] = {
15876         (char *) "self",(char *) "text", NULL
15877     };
15878
15879     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPartialTextExtents",kwnames,&obj0,&obj1)) goto fail;
15880     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15881     if (SWIG_arg_fail(1)) SWIG_fail;
15882     {
15883         arg2 = wxString_in_helper(obj1);
15884         if (arg2 == NULL) SWIG_fail;
15885         temp2 = true;
15886     }
15887     {
15888         PyThreadState* __tstate = wxPyBeginAllowThreads();
15889         result = wxDC_GetPartialTextExtents(arg1,(wxString const &)*arg2);
15890
15891         wxPyEndAllowThreads(__tstate);
15892         if (PyErr_Occurred()) SWIG_fail;
15893     }
15894     {
15895         resultobj = PyList_New(0);
15896         size_t idx;
15897         for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15898             PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15899             PyList_Append(resultobj, val);
15900             Py_DECREF(val);
15901         }
15902     }
15903     {
15904         if (temp2)
15905         delete arg2;
15906     }
15907     return resultobj;
15908     fail:
15909     {
15910         if (temp2)
15911         delete arg2;
15912     }
15913     return NULL;
15914 }
15915
15916
15917 static PyObject *_wrap_DC_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
15918     PyObject *resultobj;
15919     wxDC *arg1 = (wxDC *) 0 ;
15920     wxSize result;
15921     PyObject * obj0 = 0 ;
15922     char *kwnames[] = {
15923         (char *) "self", NULL
15924     };
15925
15926     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSize",kwnames,&obj0)) goto fail;
15927     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15928     if (SWIG_arg_fail(1)) SWIG_fail;
15929     {
15930         PyThreadState* __tstate = wxPyBeginAllowThreads();
15931         result = (arg1)->GetSize();
15932
15933         wxPyEndAllowThreads(__tstate);
15934         if (PyErr_Occurred()) SWIG_fail;
15935     }
15936     {
15937         wxSize * resultptr;
15938         resultptr = new wxSize((wxSize &)(result));
15939         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15940     }
15941     return resultobj;
15942     fail:
15943     return NULL;
15944 }
15945
15946
15947 static PyObject *_wrap_DC_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15948     PyObject *resultobj;
15949     wxDC *arg1 = (wxDC *) 0 ;
15950     int *arg2 = (int *) 0 ;
15951     int *arg3 = (int *) 0 ;
15952     int temp2 ;
15953     int res2 = 0 ;
15954     int temp3 ;
15955     int res3 = 0 ;
15956     PyObject * obj0 = 0 ;
15957     char *kwnames[] = {
15958         (char *) "self", NULL
15959     };
15960
15961     arg2 = &temp2; res2 = SWIG_NEWOBJ;
15962     arg3 = &temp3; res3 = SWIG_NEWOBJ;
15963     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeTuple",kwnames,&obj0)) goto fail;
15964     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15965     if (SWIG_arg_fail(1)) SWIG_fail;
15966     {
15967         PyThreadState* __tstate = wxPyBeginAllowThreads();
15968         (arg1)->GetSize(arg2,arg3);
15969
15970         wxPyEndAllowThreads(__tstate);
15971         if (PyErr_Occurred()) SWIG_fail;
15972     }
15973     Py_INCREF(Py_None); resultobj = Py_None;
15974     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15975     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15976     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15977     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15978     return resultobj;
15979     fail:
15980     return NULL;
15981 }
15982
15983
15984 static PyObject *_wrap_DC_GetSizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
15985     PyObject *resultobj;
15986     wxDC *arg1 = (wxDC *) 0 ;
15987     wxSize result;
15988     PyObject * obj0 = 0 ;
15989     char *kwnames[] = {
15990         (char *) "self", NULL
15991     };
15992
15993     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMM",kwnames,&obj0)) goto fail;
15994     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15995     if (SWIG_arg_fail(1)) SWIG_fail;
15996     {
15997         PyThreadState* __tstate = wxPyBeginAllowThreads();
15998         result = ((wxDC const *)arg1)->GetSizeMM();
15999
16000         wxPyEndAllowThreads(__tstate);
16001         if (PyErr_Occurred()) SWIG_fail;
16002     }
16003     {
16004         wxSize * resultptr;
16005         resultptr = new wxSize((wxSize &)(result));
16006         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16007     }
16008     return resultobj;
16009     fail:
16010     return NULL;
16011 }
16012
16013
16014 static PyObject *_wrap_DC_GetSizeMMTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16015     PyObject *resultobj;
16016     wxDC *arg1 = (wxDC *) 0 ;
16017     int *arg2 = (int *) 0 ;
16018     int *arg3 = (int *) 0 ;
16019     int temp2 ;
16020     int res2 = 0 ;
16021     int temp3 ;
16022     int res3 = 0 ;
16023     PyObject * obj0 = 0 ;
16024     char *kwnames[] = {
16025         (char *) "self", NULL
16026     };
16027
16028     arg2 = &temp2; res2 = SWIG_NEWOBJ;
16029     arg3 = &temp3; res3 = SWIG_NEWOBJ;
16030     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMMTuple",kwnames,&obj0)) goto fail;
16031     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16032     if (SWIG_arg_fail(1)) SWIG_fail;
16033     {
16034         PyThreadState* __tstate = wxPyBeginAllowThreads();
16035         ((wxDC const *)arg1)->GetSizeMM(arg2,arg3);
16036
16037         wxPyEndAllowThreads(__tstate);
16038         if (PyErr_Occurred()) SWIG_fail;
16039     }
16040     Py_INCREF(Py_None); resultobj = Py_None;
16041     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16042     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16043     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16044     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16045     return resultobj;
16046     fail:
16047     return NULL;
16048 }
16049
16050
16051 static PyObject *_wrap_DC_DeviceToLogicalX(PyObject *, PyObject *args, PyObject *kwargs) {
16052     PyObject *resultobj;
16053     wxDC *arg1 = (wxDC *) 0 ;
16054     int arg2 ;
16055     int result;
16056     PyObject * obj0 = 0 ;
16057     PyObject * obj1 = 0 ;
16058     char *kwnames[] = {
16059         (char *) "self",(char *) "x", NULL
16060     };
16061
16062     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalX",kwnames,&obj0,&obj1)) goto fail;
16063     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16064     if (SWIG_arg_fail(1)) SWIG_fail;
16065     {
16066         arg2 = (int)(SWIG_As_int(obj1));
16067         if (SWIG_arg_fail(2)) SWIG_fail;
16068     }
16069     {
16070         PyThreadState* __tstate = wxPyBeginAllowThreads();
16071         result = (int)((wxDC const *)arg1)->DeviceToLogicalX(arg2);
16072
16073         wxPyEndAllowThreads(__tstate);
16074         if (PyErr_Occurred()) SWIG_fail;
16075     }
16076     {
16077         resultobj = SWIG_From_int((int)(result));
16078     }
16079     return resultobj;
16080     fail:
16081     return NULL;
16082 }
16083
16084
16085 static PyObject *_wrap_DC_DeviceToLogicalY(PyObject *, PyObject *args, PyObject *kwargs) {
16086     PyObject *resultobj;
16087     wxDC *arg1 = (wxDC *) 0 ;
16088     int arg2 ;
16089     int result;
16090     PyObject * obj0 = 0 ;
16091     PyObject * obj1 = 0 ;
16092     char *kwnames[] = {
16093         (char *) "self",(char *) "y", NULL
16094     };
16095
16096     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalY",kwnames,&obj0,&obj1)) goto fail;
16097     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16098     if (SWIG_arg_fail(1)) SWIG_fail;
16099     {
16100         arg2 = (int)(SWIG_As_int(obj1));
16101         if (SWIG_arg_fail(2)) SWIG_fail;
16102     }
16103     {
16104         PyThreadState* __tstate = wxPyBeginAllowThreads();
16105         result = (int)((wxDC const *)arg1)->DeviceToLogicalY(arg2);
16106
16107         wxPyEndAllowThreads(__tstate);
16108         if (PyErr_Occurred()) SWIG_fail;
16109     }
16110     {
16111         resultobj = SWIG_From_int((int)(result));
16112     }
16113     return resultobj;
16114     fail:
16115     return NULL;
16116 }
16117
16118
16119 static PyObject *_wrap_DC_DeviceToLogicalXRel(PyObject *, PyObject *args, PyObject *kwargs) {
16120     PyObject *resultobj;
16121     wxDC *arg1 = (wxDC *) 0 ;
16122     int arg2 ;
16123     int result;
16124     PyObject * obj0 = 0 ;
16125     PyObject * obj1 = 0 ;
16126     char *kwnames[] = {
16127         (char *) "self",(char *) "x", NULL
16128     };
16129
16130     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalXRel",kwnames,&obj0,&obj1)) goto fail;
16131     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16132     if (SWIG_arg_fail(1)) SWIG_fail;
16133     {
16134         arg2 = (int)(SWIG_As_int(obj1));
16135         if (SWIG_arg_fail(2)) SWIG_fail;
16136     }
16137     {
16138         PyThreadState* __tstate = wxPyBeginAllowThreads();
16139         result = (int)((wxDC const *)arg1)->DeviceToLogicalXRel(arg2);
16140
16141         wxPyEndAllowThreads(__tstate);
16142         if (PyErr_Occurred()) SWIG_fail;
16143     }
16144     {
16145         resultobj = SWIG_From_int((int)(result));
16146     }
16147     return resultobj;
16148     fail:
16149     return NULL;
16150 }
16151
16152
16153 static PyObject *_wrap_DC_DeviceToLogicalYRel(PyObject *, PyObject *args, PyObject *kwargs) {
16154     PyObject *resultobj;
16155     wxDC *arg1 = (wxDC *) 0 ;
16156     int arg2 ;
16157     int result;
16158     PyObject * obj0 = 0 ;
16159     PyObject * obj1 = 0 ;
16160     char *kwnames[] = {
16161         (char *) "self",(char *) "y", NULL
16162     };
16163
16164     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalYRel",kwnames,&obj0,&obj1)) goto fail;
16165     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16166     if (SWIG_arg_fail(1)) SWIG_fail;
16167     {
16168         arg2 = (int)(SWIG_As_int(obj1));
16169         if (SWIG_arg_fail(2)) SWIG_fail;
16170     }
16171     {
16172         PyThreadState* __tstate = wxPyBeginAllowThreads();
16173         result = (int)((wxDC const *)arg1)->DeviceToLogicalYRel(arg2);
16174
16175         wxPyEndAllowThreads(__tstate);
16176         if (PyErr_Occurred()) SWIG_fail;
16177     }
16178     {
16179         resultobj = SWIG_From_int((int)(result));
16180     }
16181     return resultobj;
16182     fail:
16183     return NULL;
16184 }
16185
16186
16187 static PyObject *_wrap_DC_LogicalToDeviceX(PyObject *, PyObject *args, PyObject *kwargs) {
16188     PyObject *resultobj;
16189     wxDC *arg1 = (wxDC *) 0 ;
16190     int arg2 ;
16191     int result;
16192     PyObject * obj0 = 0 ;
16193     PyObject * obj1 = 0 ;
16194     char *kwnames[] = {
16195         (char *) "self",(char *) "x", NULL
16196     };
16197
16198     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceX",kwnames,&obj0,&obj1)) goto fail;
16199     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16200     if (SWIG_arg_fail(1)) SWIG_fail;
16201     {
16202         arg2 = (int)(SWIG_As_int(obj1));
16203         if (SWIG_arg_fail(2)) SWIG_fail;
16204     }
16205     {
16206         PyThreadState* __tstate = wxPyBeginAllowThreads();
16207         result = (int)((wxDC const *)arg1)->LogicalToDeviceX(arg2);
16208
16209         wxPyEndAllowThreads(__tstate);
16210         if (PyErr_Occurred()) SWIG_fail;
16211     }
16212     {
16213         resultobj = SWIG_From_int((int)(result));
16214     }
16215     return resultobj;
16216     fail:
16217     return NULL;
16218 }
16219
16220
16221 static PyObject *_wrap_DC_LogicalToDeviceY(PyObject *, PyObject *args, PyObject *kwargs) {
16222     PyObject *resultobj;
16223     wxDC *arg1 = (wxDC *) 0 ;
16224     int arg2 ;
16225     int result;
16226     PyObject * obj0 = 0 ;
16227     PyObject * obj1 = 0 ;
16228     char *kwnames[] = {
16229         (char *) "self",(char *) "y", NULL
16230     };
16231
16232     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceY",kwnames,&obj0,&obj1)) goto fail;
16233     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16234     if (SWIG_arg_fail(1)) SWIG_fail;
16235     {
16236         arg2 = (int)(SWIG_As_int(obj1));
16237         if (SWIG_arg_fail(2)) SWIG_fail;
16238     }
16239     {
16240         PyThreadState* __tstate = wxPyBeginAllowThreads();
16241         result = (int)((wxDC const *)arg1)->LogicalToDeviceY(arg2);
16242
16243         wxPyEndAllowThreads(__tstate);
16244         if (PyErr_Occurred()) SWIG_fail;
16245     }
16246     {
16247         resultobj = SWIG_From_int((int)(result));
16248     }
16249     return resultobj;
16250     fail:
16251     return NULL;
16252 }
16253
16254
16255 static PyObject *_wrap_DC_LogicalToDeviceXRel(PyObject *, PyObject *args, PyObject *kwargs) {
16256     PyObject *resultobj;
16257     wxDC *arg1 = (wxDC *) 0 ;
16258     int arg2 ;
16259     int result;
16260     PyObject * obj0 = 0 ;
16261     PyObject * obj1 = 0 ;
16262     char *kwnames[] = {
16263         (char *) "self",(char *) "x", NULL
16264     };
16265
16266     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceXRel",kwnames,&obj0,&obj1)) goto fail;
16267     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16268     if (SWIG_arg_fail(1)) SWIG_fail;
16269     {
16270         arg2 = (int)(SWIG_As_int(obj1));
16271         if (SWIG_arg_fail(2)) SWIG_fail;
16272     }
16273     {
16274         PyThreadState* __tstate = wxPyBeginAllowThreads();
16275         result = (int)((wxDC const *)arg1)->LogicalToDeviceXRel(arg2);
16276
16277         wxPyEndAllowThreads(__tstate);
16278         if (PyErr_Occurred()) SWIG_fail;
16279     }
16280     {
16281         resultobj = SWIG_From_int((int)(result));
16282     }
16283     return resultobj;
16284     fail:
16285     return NULL;
16286 }
16287
16288
16289 static PyObject *_wrap_DC_LogicalToDeviceYRel(PyObject *, PyObject *args, PyObject *kwargs) {
16290     PyObject *resultobj;
16291     wxDC *arg1 = (wxDC *) 0 ;
16292     int arg2 ;
16293     int result;
16294     PyObject * obj0 = 0 ;
16295     PyObject * obj1 = 0 ;
16296     char *kwnames[] = {
16297         (char *) "self",(char *) "y", NULL
16298     };
16299
16300     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceYRel",kwnames,&obj0,&obj1)) goto fail;
16301     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16302     if (SWIG_arg_fail(1)) SWIG_fail;
16303     {
16304         arg2 = (int)(SWIG_As_int(obj1));
16305         if (SWIG_arg_fail(2)) SWIG_fail;
16306     }
16307     {
16308         PyThreadState* __tstate = wxPyBeginAllowThreads();
16309         result = (int)((wxDC const *)arg1)->LogicalToDeviceYRel(arg2);
16310
16311         wxPyEndAllowThreads(__tstate);
16312         if (PyErr_Occurred()) SWIG_fail;
16313     }
16314     {
16315         resultobj = SWIG_From_int((int)(result));
16316     }
16317     return resultobj;
16318     fail:
16319     return NULL;
16320 }
16321
16322
16323 static PyObject *_wrap_DC_CanDrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16324     PyObject *resultobj;
16325     wxDC *arg1 = (wxDC *) 0 ;
16326     bool result;
16327     PyObject * obj0 = 0 ;
16328     char *kwnames[] = {
16329         (char *) "self", NULL
16330     };
16331
16332     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanDrawBitmap",kwnames,&obj0)) goto fail;
16333     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16334     if (SWIG_arg_fail(1)) SWIG_fail;
16335     {
16336         PyThreadState* __tstate = wxPyBeginAllowThreads();
16337         result = (bool)((wxDC const *)arg1)->CanDrawBitmap();
16338
16339         wxPyEndAllowThreads(__tstate);
16340         if (PyErr_Occurred()) SWIG_fail;
16341     }
16342     {
16343         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16344     }
16345     return resultobj;
16346     fail:
16347     return NULL;
16348 }
16349
16350
16351 static PyObject *_wrap_DC_CanGetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
16352     PyObject *resultobj;
16353     wxDC *arg1 = (wxDC *) 0 ;
16354     bool result;
16355     PyObject * obj0 = 0 ;
16356     char *kwnames[] = {
16357         (char *) "self", NULL
16358     };
16359
16360     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanGetTextExtent",kwnames,&obj0)) goto fail;
16361     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16362     if (SWIG_arg_fail(1)) SWIG_fail;
16363     {
16364         PyThreadState* __tstate = wxPyBeginAllowThreads();
16365         result = (bool)((wxDC const *)arg1)->CanGetTextExtent();
16366
16367         wxPyEndAllowThreads(__tstate);
16368         if (PyErr_Occurred()) SWIG_fail;
16369     }
16370     {
16371         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16372     }
16373     return resultobj;
16374     fail:
16375     return NULL;
16376 }
16377
16378
16379 static PyObject *_wrap_DC_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
16380     PyObject *resultobj;
16381     wxDC *arg1 = (wxDC *) 0 ;
16382     int result;
16383     PyObject * obj0 = 0 ;
16384     char *kwnames[] = {
16385         (char *) "self", NULL
16386     };
16387
16388     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDepth",kwnames,&obj0)) goto fail;
16389     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16390     if (SWIG_arg_fail(1)) SWIG_fail;
16391     {
16392         PyThreadState* __tstate = wxPyBeginAllowThreads();
16393         result = (int)((wxDC const *)arg1)->GetDepth();
16394
16395         wxPyEndAllowThreads(__tstate);
16396         if (PyErr_Occurred()) SWIG_fail;
16397     }
16398     {
16399         resultobj = SWIG_From_int((int)(result));
16400     }
16401     return resultobj;
16402     fail:
16403     return NULL;
16404 }
16405
16406
16407 static PyObject *_wrap_DC_GetPPI(PyObject *, PyObject *args, PyObject *kwargs) {
16408     PyObject *resultobj;
16409     wxDC *arg1 = (wxDC *) 0 ;
16410     wxSize result;
16411     PyObject * obj0 = 0 ;
16412     char *kwnames[] = {
16413         (char *) "self", NULL
16414     };
16415
16416     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPPI",kwnames,&obj0)) goto fail;
16417     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16418     if (SWIG_arg_fail(1)) SWIG_fail;
16419     {
16420         PyThreadState* __tstate = wxPyBeginAllowThreads();
16421         result = ((wxDC const *)arg1)->GetPPI();
16422
16423         wxPyEndAllowThreads(__tstate);
16424         if (PyErr_Occurred()) SWIG_fail;
16425     }
16426     {
16427         wxSize * resultptr;
16428         resultptr = new wxSize((wxSize &)(result));
16429         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16430     }
16431     return resultobj;
16432     fail:
16433     return NULL;
16434 }
16435
16436
16437 static PyObject *_wrap_DC_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
16438     PyObject *resultobj;
16439     wxDC *arg1 = (wxDC *) 0 ;
16440     bool result;
16441     PyObject * obj0 = 0 ;
16442     char *kwnames[] = {
16443         (char *) "self", NULL
16444     };
16445
16446     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Ok",kwnames,&obj0)) goto fail;
16447     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16448     if (SWIG_arg_fail(1)) SWIG_fail;
16449     {
16450         PyThreadState* __tstate = wxPyBeginAllowThreads();
16451         result = (bool)((wxDC const *)arg1)->Ok();
16452
16453         wxPyEndAllowThreads(__tstate);
16454         if (PyErr_Occurred()) SWIG_fail;
16455     }
16456     {
16457         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16458     }
16459     return resultobj;
16460     fail:
16461     return NULL;
16462 }
16463
16464
16465 static PyObject *_wrap_DC_GetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
16466     PyObject *resultobj;
16467     wxDC *arg1 = (wxDC *) 0 ;
16468     int result;
16469     PyObject * obj0 = 0 ;
16470     char *kwnames[] = {
16471         (char *) "self", NULL
16472     };
16473
16474     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackgroundMode",kwnames,&obj0)) goto fail;
16475     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16476     if (SWIG_arg_fail(1)) SWIG_fail;
16477     {
16478         PyThreadState* __tstate = wxPyBeginAllowThreads();
16479         result = (int)((wxDC const *)arg1)->GetBackgroundMode();
16480
16481         wxPyEndAllowThreads(__tstate);
16482         if (PyErr_Occurred()) SWIG_fail;
16483     }
16484     {
16485         resultobj = SWIG_From_int((int)(result));
16486     }
16487     return resultobj;
16488     fail:
16489     return NULL;
16490 }
16491
16492
16493 static PyObject *_wrap_DC_GetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16494     PyObject *resultobj;
16495     wxDC *arg1 = (wxDC *) 0 ;
16496     wxBrush *result;
16497     PyObject * obj0 = 0 ;
16498     char *kwnames[] = {
16499         (char *) "self", NULL
16500     };
16501
16502     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackground",kwnames,&obj0)) goto fail;
16503     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16504     if (SWIG_arg_fail(1)) SWIG_fail;
16505     {
16506         PyThreadState* __tstate = wxPyBeginAllowThreads();
16507         {
16508             wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBackground();
16509             result = (wxBrush *) &_result_ref;
16510         }
16511
16512         wxPyEndAllowThreads(__tstate);
16513         if (PyErr_Occurred()) SWIG_fail;
16514     }
16515     {
16516         wxBrush* resultptr = new wxBrush(*result);
16517         resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
16518     }
16519     return resultobj;
16520     fail:
16521     return NULL;
16522 }
16523
16524
16525 static PyObject *_wrap_DC_GetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
16526     PyObject *resultobj;
16527     wxDC *arg1 = (wxDC *) 0 ;
16528     wxBrush *result;
16529     PyObject * obj0 = 0 ;
16530     char *kwnames[] = {
16531         (char *) "self", NULL
16532     };
16533
16534     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBrush",kwnames,&obj0)) goto fail;
16535     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16536     if (SWIG_arg_fail(1)) SWIG_fail;
16537     {
16538         PyThreadState* __tstate = wxPyBeginAllowThreads();
16539         {
16540             wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBrush();
16541             result = (wxBrush *) &_result_ref;
16542         }
16543
16544         wxPyEndAllowThreads(__tstate);
16545         if (PyErr_Occurred()) SWIG_fail;
16546     }
16547     {
16548         wxBrush* resultptr = new wxBrush(*result);
16549         resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
16550     }
16551     return resultobj;
16552     fail:
16553     return NULL;
16554 }
16555
16556
16557 static PyObject *_wrap_DC_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
16558     PyObject *resultobj;
16559     wxDC *arg1 = (wxDC *) 0 ;
16560     wxFont *result;
16561     PyObject * obj0 = 0 ;
16562     char *kwnames[] = {
16563         (char *) "self", NULL
16564     };
16565
16566     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetFont",kwnames,&obj0)) goto fail;
16567     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16568     if (SWIG_arg_fail(1)) SWIG_fail;
16569     {
16570         PyThreadState* __tstate = wxPyBeginAllowThreads();
16571         {
16572             wxFont const &_result_ref = ((wxDC const *)arg1)->GetFont();
16573             result = (wxFont *) &_result_ref;
16574         }
16575
16576         wxPyEndAllowThreads(__tstate);
16577         if (PyErr_Occurred()) SWIG_fail;
16578     }
16579     {
16580         wxFont* resultptr = new wxFont(*result);
16581         resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxFont, 1);
16582     }
16583     return resultobj;
16584     fail:
16585     return NULL;
16586 }
16587
16588
16589 static PyObject *_wrap_DC_GetPen(PyObject *, PyObject *args, PyObject *kwargs) {
16590     PyObject *resultobj;
16591     wxDC *arg1 = (wxDC *) 0 ;
16592     wxPen *result;
16593     PyObject * obj0 = 0 ;
16594     char *kwnames[] = {
16595         (char *) "self", NULL
16596     };
16597
16598     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPen",kwnames,&obj0)) goto fail;
16599     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16600     if (SWIG_arg_fail(1)) SWIG_fail;
16601     {
16602         PyThreadState* __tstate = wxPyBeginAllowThreads();
16603         {
16604             wxPen const &_result_ref = ((wxDC const *)arg1)->GetPen();
16605             result = (wxPen *) &_result_ref;
16606         }
16607
16608         wxPyEndAllowThreads(__tstate);
16609         if (PyErr_Occurred()) SWIG_fail;
16610     }
16611     {
16612         wxPen* resultptr = new wxPen(*result);
16613         resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxPen, 1);
16614     }
16615     return resultobj;
16616     fail:
16617     return NULL;
16618 }
16619
16620
16621 static PyObject *_wrap_DC_GetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16622     PyObject *resultobj;
16623     wxDC *arg1 = (wxDC *) 0 ;
16624     wxColour *result;
16625     PyObject * obj0 = 0 ;
16626     char *kwnames[] = {
16627         (char *) "self", NULL
16628     };
16629
16630     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextBackground",kwnames,&obj0)) goto fail;
16631     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16632     if (SWIG_arg_fail(1)) SWIG_fail;
16633     {
16634         PyThreadState* __tstate = wxPyBeginAllowThreads();
16635         {
16636             wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextBackground();
16637             result = (wxColour *) &_result_ref;
16638         }
16639
16640         wxPyEndAllowThreads(__tstate);
16641         if (PyErr_Occurred()) SWIG_fail;
16642     }
16643     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
16644     return resultobj;
16645     fail:
16646     return NULL;
16647 }
16648
16649
16650 static PyObject *_wrap_DC_GetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16651     PyObject *resultobj;
16652     wxDC *arg1 = (wxDC *) 0 ;
16653     wxColour *result;
16654     PyObject * obj0 = 0 ;
16655     char *kwnames[] = {
16656         (char *) "self", NULL
16657     };
16658
16659     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextForeground",kwnames,&obj0)) goto fail;
16660     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16661     if (SWIG_arg_fail(1)) SWIG_fail;
16662     {
16663         PyThreadState* __tstate = wxPyBeginAllowThreads();
16664         {
16665             wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextForeground();
16666             result = (wxColour *) &_result_ref;
16667         }
16668
16669         wxPyEndAllowThreads(__tstate);
16670         if (PyErr_Occurred()) SWIG_fail;
16671     }
16672     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
16673     return resultobj;
16674     fail:
16675     return NULL;
16676 }
16677
16678
16679 static PyObject *_wrap_DC_SetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16680     PyObject *resultobj;
16681     wxDC *arg1 = (wxDC *) 0 ;
16682     wxColour *arg2 = 0 ;
16683     wxColour temp2 ;
16684     PyObject * obj0 = 0 ;
16685     PyObject * obj1 = 0 ;
16686     char *kwnames[] = {
16687         (char *) "self",(char *) "colour", NULL
16688     };
16689
16690     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextForeground",kwnames,&obj0,&obj1)) goto fail;
16691     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16692     if (SWIG_arg_fail(1)) SWIG_fail;
16693     {
16694         arg2 = &temp2;
16695         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16696     }
16697     {
16698         PyThreadState* __tstate = wxPyBeginAllowThreads();
16699         (arg1)->SetTextForeground((wxColour const &)*arg2);
16700
16701         wxPyEndAllowThreads(__tstate);
16702         if (PyErr_Occurred()) SWIG_fail;
16703     }
16704     Py_INCREF(Py_None); resultobj = Py_None;
16705     return resultobj;
16706     fail:
16707     return NULL;
16708 }
16709
16710
16711 static PyObject *_wrap_DC_SetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16712     PyObject *resultobj;
16713     wxDC *arg1 = (wxDC *) 0 ;
16714     wxColour *arg2 = 0 ;
16715     wxColour temp2 ;
16716     PyObject * obj0 = 0 ;
16717     PyObject * obj1 = 0 ;
16718     char *kwnames[] = {
16719         (char *) "self",(char *) "colour", NULL
16720     };
16721
16722     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextBackground",kwnames,&obj0,&obj1)) goto fail;
16723     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16724     if (SWIG_arg_fail(1)) SWIG_fail;
16725     {
16726         arg2 = &temp2;
16727         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16728     }
16729     {
16730         PyThreadState* __tstate = wxPyBeginAllowThreads();
16731         (arg1)->SetTextBackground((wxColour const &)*arg2);
16732
16733         wxPyEndAllowThreads(__tstate);
16734         if (PyErr_Occurred()) SWIG_fail;
16735     }
16736     Py_INCREF(Py_None); resultobj = Py_None;
16737     return resultobj;
16738     fail:
16739     return NULL;
16740 }
16741
16742
16743 static PyObject *_wrap_DC_GetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16744     PyObject *resultobj;
16745     wxDC *arg1 = (wxDC *) 0 ;
16746     int result;
16747     PyObject * obj0 = 0 ;
16748     char *kwnames[] = {
16749         (char *) "self", NULL
16750     };
16751
16752     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetMapMode",kwnames,&obj0)) goto fail;
16753     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16754     if (SWIG_arg_fail(1)) SWIG_fail;
16755     {
16756         PyThreadState* __tstate = wxPyBeginAllowThreads();
16757         result = (int)((wxDC const *)arg1)->GetMapMode();
16758
16759         wxPyEndAllowThreads(__tstate);
16760         if (PyErr_Occurred()) SWIG_fail;
16761     }
16762     {
16763         resultobj = SWIG_From_int((int)(result));
16764     }
16765     return resultobj;
16766     fail:
16767     return NULL;
16768 }
16769
16770
16771 static PyObject *_wrap_DC_SetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16772     PyObject *resultobj;
16773     wxDC *arg1 = (wxDC *) 0 ;
16774     int arg2 ;
16775     PyObject * obj0 = 0 ;
16776     PyObject * obj1 = 0 ;
16777     char *kwnames[] = {
16778         (char *) "self",(char *) "mode", NULL
16779     };
16780
16781     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetMapMode",kwnames,&obj0,&obj1)) goto fail;
16782     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16783     if (SWIG_arg_fail(1)) SWIG_fail;
16784     {
16785         arg2 = (int)(SWIG_As_int(obj1));
16786         if (SWIG_arg_fail(2)) SWIG_fail;
16787     }
16788     {
16789         PyThreadState* __tstate = wxPyBeginAllowThreads();
16790         (arg1)->SetMapMode(arg2);
16791
16792         wxPyEndAllowThreads(__tstate);
16793         if (PyErr_Occurred()) SWIG_fail;
16794     }
16795     Py_INCREF(Py_None); resultobj = Py_None;
16796     return resultobj;
16797     fail:
16798     return NULL;
16799 }
16800
16801
16802 static PyObject *_wrap_DC_GetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16803     PyObject *resultobj;
16804     wxDC *arg1 = (wxDC *) 0 ;
16805     double *arg2 = (double *) 0 ;
16806     double *arg3 = (double *) 0 ;
16807     double temp2 ;
16808     int res2 = 0 ;
16809     double temp3 ;
16810     int res3 = 0 ;
16811     PyObject * obj0 = 0 ;
16812     char *kwnames[] = {
16813         (char *) "self", NULL
16814     };
16815
16816     arg2 = &temp2; res2 = SWIG_NEWOBJ;
16817     arg3 = &temp3; res3 = SWIG_NEWOBJ;
16818     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetUserScale",kwnames,&obj0)) 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         PyThreadState* __tstate = wxPyBeginAllowThreads();
16823         ((wxDC const *)arg1)->GetUserScale(arg2,arg3);
16824
16825         wxPyEndAllowThreads(__tstate);
16826         if (PyErr_Occurred()) SWIG_fail;
16827     }
16828     Py_INCREF(Py_None); resultobj = Py_None;
16829     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16830     SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16831     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16832     SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16833     return resultobj;
16834     fail:
16835     return NULL;
16836 }
16837
16838
16839 static PyObject *_wrap_DC_SetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16840     PyObject *resultobj;
16841     wxDC *arg1 = (wxDC *) 0 ;
16842     double arg2 ;
16843     double arg3 ;
16844     PyObject * obj0 = 0 ;
16845     PyObject * obj1 = 0 ;
16846     PyObject * obj2 = 0 ;
16847     char *kwnames[] = {
16848         (char *) "self",(char *) "x",(char *) "y", NULL
16849     };
16850
16851     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetUserScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16852     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16853     if (SWIG_arg_fail(1)) SWIG_fail;
16854     {
16855         arg2 = (double)(SWIG_As_double(obj1));
16856         if (SWIG_arg_fail(2)) SWIG_fail;
16857     }
16858     {
16859         arg3 = (double)(SWIG_As_double(obj2));
16860         if (SWIG_arg_fail(3)) SWIG_fail;
16861     }
16862     {
16863         PyThreadState* __tstate = wxPyBeginAllowThreads();
16864         (arg1)->SetUserScale(arg2,arg3);
16865
16866         wxPyEndAllowThreads(__tstate);
16867         if (PyErr_Occurred()) SWIG_fail;
16868     }
16869     Py_INCREF(Py_None); resultobj = Py_None;
16870     return resultobj;
16871     fail:
16872     return NULL;
16873 }
16874
16875
16876 static PyObject *_wrap_DC_GetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16877     PyObject *resultobj;
16878     wxDC *arg1 = (wxDC *) 0 ;
16879     double *arg2 = (double *) 0 ;
16880     double *arg3 = (double *) 0 ;
16881     double temp2 ;
16882     int res2 = 0 ;
16883     double temp3 ;
16884     int res3 = 0 ;
16885     PyObject * obj0 = 0 ;
16886     char *kwnames[] = {
16887         (char *) "self", NULL
16888     };
16889
16890     arg2 = &temp2; res2 = SWIG_NEWOBJ;
16891     arg3 = &temp3; res3 = SWIG_NEWOBJ;
16892     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalScale",kwnames,&obj0)) goto fail;
16893     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16894     if (SWIG_arg_fail(1)) SWIG_fail;
16895     {
16896         PyThreadState* __tstate = wxPyBeginAllowThreads();
16897         (arg1)->GetLogicalScale(arg2,arg3);
16898
16899         wxPyEndAllowThreads(__tstate);
16900         if (PyErr_Occurred()) SWIG_fail;
16901     }
16902     Py_INCREF(Py_None); resultobj = Py_None;
16903     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16904     SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16905     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16906     SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16907     return resultobj;
16908     fail:
16909     return NULL;
16910 }
16911
16912
16913 static PyObject *_wrap_DC_SetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16914     PyObject *resultobj;
16915     wxDC *arg1 = (wxDC *) 0 ;
16916     double arg2 ;
16917     double arg3 ;
16918     PyObject * obj0 = 0 ;
16919     PyObject * obj1 = 0 ;
16920     PyObject * obj2 = 0 ;
16921     char *kwnames[] = {
16922         (char *) "self",(char *) "x",(char *) "y", NULL
16923     };
16924
16925     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16926     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16927     if (SWIG_arg_fail(1)) SWIG_fail;
16928     {
16929         arg2 = (double)(SWIG_As_double(obj1));
16930         if (SWIG_arg_fail(2)) SWIG_fail;
16931     }
16932     {
16933         arg3 = (double)(SWIG_As_double(obj2));
16934         if (SWIG_arg_fail(3)) SWIG_fail;
16935     }
16936     {
16937         PyThreadState* __tstate = wxPyBeginAllowThreads();
16938         (arg1)->SetLogicalScale(arg2,arg3);
16939
16940         wxPyEndAllowThreads(__tstate);
16941         if (PyErr_Occurred()) SWIG_fail;
16942     }
16943     Py_INCREF(Py_None); resultobj = Py_None;
16944     return resultobj;
16945     fail:
16946     return NULL;
16947 }
16948
16949
16950 static PyObject *_wrap_DC_GetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16951     PyObject *resultobj;
16952     wxDC *arg1 = (wxDC *) 0 ;
16953     wxPoint result;
16954     PyObject * obj0 = 0 ;
16955     char *kwnames[] = {
16956         (char *) "self", NULL
16957     };
16958
16959     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOrigin",kwnames,&obj0)) goto fail;
16960     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16961     if (SWIG_arg_fail(1)) SWIG_fail;
16962     {
16963         PyThreadState* __tstate = wxPyBeginAllowThreads();
16964         result = ((wxDC const *)arg1)->GetLogicalOrigin();
16965
16966         wxPyEndAllowThreads(__tstate);
16967         if (PyErr_Occurred()) SWIG_fail;
16968     }
16969     {
16970         wxPoint * resultptr;
16971         resultptr = new wxPoint((wxPoint &)(result));
16972         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16973     }
16974     return resultobj;
16975     fail:
16976     return NULL;
16977 }
16978
16979
16980 static PyObject *_wrap_DC_GetLogicalOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16981     PyObject *resultobj;
16982     wxDC *arg1 = (wxDC *) 0 ;
16983     int *arg2 = (int *) 0 ;
16984     int *arg3 = (int *) 0 ;
16985     int temp2 ;
16986     int res2 = 0 ;
16987     int temp3 ;
16988     int res3 = 0 ;
16989     PyObject * obj0 = 0 ;
16990     char *kwnames[] = {
16991         (char *) "self", NULL
16992     };
16993
16994     arg2 = &temp2; res2 = SWIG_NEWOBJ;
16995     arg3 = &temp3; res3 = SWIG_NEWOBJ;
16996     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOriginTuple",kwnames,&obj0)) 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         PyThreadState* __tstate = wxPyBeginAllowThreads();
17001         ((wxDC const *)arg1)->GetLogicalOrigin(arg2,arg3);
17002
17003         wxPyEndAllowThreads(__tstate);
17004         if (PyErr_Occurred()) SWIG_fail;
17005     }
17006     Py_INCREF(Py_None); resultobj = Py_None;
17007     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17008     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
17009     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17010     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
17011     return resultobj;
17012     fail:
17013     return NULL;
17014 }
17015
17016
17017 static PyObject *_wrap_DC_SetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
17018     PyObject *resultobj;
17019     wxDC *arg1 = (wxDC *) 0 ;
17020     int arg2 ;
17021     int arg3 ;
17022     PyObject * obj0 = 0 ;
17023     PyObject * obj1 = 0 ;
17024     PyObject * obj2 = 0 ;
17025     char *kwnames[] = {
17026         (char *) "self",(char *) "x",(char *) "y", NULL
17027     };
17028
17029     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
17030     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17031     if (SWIG_arg_fail(1)) SWIG_fail;
17032     {
17033         arg2 = (int)(SWIG_As_int(obj1));
17034         if (SWIG_arg_fail(2)) SWIG_fail;
17035     }
17036     {
17037         arg3 = (int)(SWIG_As_int(obj2));
17038         if (SWIG_arg_fail(3)) SWIG_fail;
17039     }
17040     {
17041         PyThreadState* __tstate = wxPyBeginAllowThreads();
17042         (arg1)->SetLogicalOrigin(arg2,arg3);
17043
17044         wxPyEndAllowThreads(__tstate);
17045         if (PyErr_Occurred()) SWIG_fail;
17046     }
17047     Py_INCREF(Py_None); resultobj = Py_None;
17048     return resultobj;
17049     fail:
17050     return NULL;
17051 }
17052
17053
17054 static PyObject *_wrap_DC_SetLogicalOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
17055     PyObject *resultobj;
17056     wxDC *arg1 = (wxDC *) 0 ;
17057     wxPoint *arg2 = 0 ;
17058     wxPoint temp2 ;
17059     PyObject * obj0 = 0 ;
17060     PyObject * obj1 = 0 ;
17061     char *kwnames[] = {
17062         (char *) "self",(char *) "point", NULL
17063     };
17064
17065     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalOriginPoint",kwnames,&obj0,&obj1)) goto fail;
17066     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17067     if (SWIG_arg_fail(1)) SWIG_fail;
17068     {
17069         arg2 = &temp2;
17070         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17071     }
17072     {
17073         PyThreadState* __tstate = wxPyBeginAllowThreads();
17074         wxDC_SetLogicalOriginPoint(arg1,(wxPoint const &)*arg2);
17075
17076         wxPyEndAllowThreads(__tstate);
17077         if (PyErr_Occurred()) SWIG_fail;
17078     }
17079     Py_INCREF(Py_None); resultobj = Py_None;
17080     return resultobj;
17081     fail:
17082     return NULL;
17083 }
17084
17085
17086 static PyObject *_wrap_DC_GetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
17087     PyObject *resultobj;
17088     wxDC *arg1 = (wxDC *) 0 ;
17089     wxPoint result;
17090     PyObject * obj0 = 0 ;
17091     char *kwnames[] = {
17092         (char *) "self", NULL
17093     };
17094
17095     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOrigin",kwnames,&obj0)) goto fail;
17096     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17097     if (SWIG_arg_fail(1)) SWIG_fail;
17098     {
17099         PyThreadState* __tstate = wxPyBeginAllowThreads();
17100         result = ((wxDC const *)arg1)->GetDeviceOrigin();
17101
17102         wxPyEndAllowThreads(__tstate);
17103         if (PyErr_Occurred()) SWIG_fail;
17104     }
17105     {
17106         wxPoint * resultptr;
17107         resultptr = new wxPoint((wxPoint &)(result));
17108         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17109     }
17110     return resultobj;
17111     fail:
17112     return NULL;
17113 }
17114
17115
17116 static PyObject *_wrap_DC_GetDeviceOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17117     PyObject *resultobj;
17118     wxDC *arg1 = (wxDC *) 0 ;
17119     int *arg2 = (int *) 0 ;
17120     int *arg3 = (int *) 0 ;
17121     int temp2 ;
17122     int res2 = 0 ;
17123     int temp3 ;
17124     int res3 = 0 ;
17125     PyObject * obj0 = 0 ;
17126     char *kwnames[] = {
17127         (char *) "self", NULL
17128     };
17129
17130     arg2 = &temp2; res2 = SWIG_NEWOBJ;
17131     arg3 = &temp3; res3 = SWIG_NEWOBJ;
17132     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOriginTuple",kwnames,&obj0)) 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         PyThreadState* __tstate = wxPyBeginAllowThreads();
17137         ((wxDC const *)arg1)->GetDeviceOrigin(arg2,arg3);
17138
17139         wxPyEndAllowThreads(__tstate);
17140         if (PyErr_Occurred()) SWIG_fail;
17141     }
17142     Py_INCREF(Py_None); resultobj = Py_None;
17143     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17144     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
17145     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17146     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
17147     return resultobj;
17148     fail:
17149     return NULL;
17150 }
17151
17152
17153 static PyObject *_wrap_DC_SetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
17154     PyObject *resultobj;
17155     wxDC *arg1 = (wxDC *) 0 ;
17156     int arg2 ;
17157     int arg3 ;
17158     PyObject * obj0 = 0 ;
17159     PyObject * obj1 = 0 ;
17160     PyObject * obj2 = 0 ;
17161     char *kwnames[] = {
17162         (char *) "self",(char *) "x",(char *) "y", NULL
17163     };
17164
17165     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetDeviceOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
17166     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17167     if (SWIG_arg_fail(1)) SWIG_fail;
17168     {
17169         arg2 = (int)(SWIG_As_int(obj1));
17170         if (SWIG_arg_fail(2)) SWIG_fail;
17171     }
17172     {
17173         arg3 = (int)(SWIG_As_int(obj2));
17174         if (SWIG_arg_fail(3)) SWIG_fail;
17175     }
17176     {
17177         PyThreadState* __tstate = wxPyBeginAllowThreads();
17178         (arg1)->SetDeviceOrigin(arg2,arg3);
17179
17180         wxPyEndAllowThreads(__tstate);
17181         if (PyErr_Occurred()) SWIG_fail;
17182     }
17183     Py_INCREF(Py_None); resultobj = Py_None;
17184     return resultobj;
17185     fail:
17186     return NULL;
17187 }
17188
17189
17190 static PyObject *_wrap_DC_SetDeviceOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
17191     PyObject *resultobj;
17192     wxDC *arg1 = (wxDC *) 0 ;
17193     wxPoint *arg2 = 0 ;
17194     wxPoint temp2 ;
17195     PyObject * obj0 = 0 ;
17196     PyObject * obj1 = 0 ;
17197     char *kwnames[] = {
17198         (char *) "self",(char *) "point", NULL
17199     };
17200
17201     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetDeviceOriginPoint",kwnames,&obj0,&obj1)) 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 = &temp2;
17206         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17207     }
17208     {
17209         PyThreadState* __tstate = wxPyBeginAllowThreads();
17210         wxDC_SetDeviceOriginPoint(arg1,(wxPoint const &)*arg2);
17211
17212         wxPyEndAllowThreads(__tstate);
17213         if (PyErr_Occurred()) SWIG_fail;
17214     }
17215     Py_INCREF(Py_None); resultobj = Py_None;
17216     return resultobj;
17217     fail:
17218     return NULL;
17219 }
17220
17221
17222 static PyObject *_wrap_DC_SetAxisOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
17223     PyObject *resultobj;
17224     wxDC *arg1 = (wxDC *) 0 ;
17225     bool arg2 ;
17226     bool arg3 ;
17227     PyObject * obj0 = 0 ;
17228     PyObject * obj1 = 0 ;
17229     PyObject * obj2 = 0 ;
17230     char *kwnames[] = {
17231         (char *) "self",(char *) "xLeftRight",(char *) "yBottomUp", NULL
17232     };
17233
17234     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetAxisOrientation",kwnames,&obj0,&obj1,&obj2)) goto fail;
17235     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17236     if (SWIG_arg_fail(1)) SWIG_fail;
17237     {
17238         arg2 = (bool)(SWIG_As_bool(obj1));
17239         if (SWIG_arg_fail(2)) SWIG_fail;
17240     }
17241     {
17242         arg3 = (bool)(SWIG_As_bool(obj2));
17243         if (SWIG_arg_fail(3)) SWIG_fail;
17244     }
17245     {
17246         PyThreadState* __tstate = wxPyBeginAllowThreads();
17247         (arg1)->SetAxisOrientation(arg2,arg3);
17248
17249         wxPyEndAllowThreads(__tstate);
17250         if (PyErr_Occurred()) SWIG_fail;
17251     }
17252     Py_INCREF(Py_None); resultobj = Py_None;
17253     return resultobj;
17254     fail:
17255     return NULL;
17256 }
17257
17258
17259 static PyObject *_wrap_DC_GetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
17260     PyObject *resultobj;
17261     wxDC *arg1 = (wxDC *) 0 ;
17262     int result;
17263     PyObject * obj0 = 0 ;
17264     char *kwnames[] = {
17265         (char *) "self", NULL
17266     };
17267
17268     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalFunction",kwnames,&obj0)) goto fail;
17269     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17270     if (SWIG_arg_fail(1)) SWIG_fail;
17271     {
17272         PyThreadState* __tstate = wxPyBeginAllowThreads();
17273         result = (int)((wxDC const *)arg1)->GetLogicalFunction();
17274
17275         wxPyEndAllowThreads(__tstate);
17276         if (PyErr_Occurred()) SWIG_fail;
17277     }
17278     {
17279         resultobj = SWIG_From_int((int)(result));
17280     }
17281     return resultobj;
17282     fail:
17283     return NULL;
17284 }
17285
17286
17287 static PyObject *_wrap_DC_SetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
17288     PyObject *resultobj;
17289     wxDC *arg1 = (wxDC *) 0 ;
17290     int arg2 ;
17291     PyObject * obj0 = 0 ;
17292     PyObject * obj1 = 0 ;
17293     char *kwnames[] = {
17294         (char *) "self",(char *) "function", NULL
17295     };
17296
17297     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalFunction",kwnames,&obj0,&obj1)) goto fail;
17298     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17299     if (SWIG_arg_fail(1)) SWIG_fail;
17300     {
17301         arg2 = (int)(SWIG_As_int(obj1));
17302         if (SWIG_arg_fail(2)) SWIG_fail;
17303     }
17304     {
17305         PyThreadState* __tstate = wxPyBeginAllowThreads();
17306         (arg1)->SetLogicalFunction(arg2);
17307
17308         wxPyEndAllowThreads(__tstate);
17309         if (PyErr_Occurred()) SWIG_fail;
17310     }
17311     Py_INCREF(Py_None); resultobj = Py_None;
17312     return resultobj;
17313     fail:
17314     return NULL;
17315 }
17316
17317
17318 static PyObject *_wrap_DC_ComputeScaleAndOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
17319     PyObject *resultobj;
17320     wxDC *arg1 = (wxDC *) 0 ;
17321     PyObject * obj0 = 0 ;
17322     char *kwnames[] = {
17323         (char *) "self", NULL
17324     };
17325
17326     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ComputeScaleAndOrigin",kwnames,&obj0)) goto fail;
17327     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17328     if (SWIG_arg_fail(1)) SWIG_fail;
17329     {
17330         PyThreadState* __tstate = wxPyBeginAllowThreads();
17331         (arg1)->ComputeScaleAndOrigin();
17332
17333         wxPyEndAllowThreads(__tstate);
17334         if (PyErr_Occurred()) SWIG_fail;
17335     }
17336     Py_INCREF(Py_None); resultobj = Py_None;
17337     return resultobj;
17338     fail:
17339     return NULL;
17340 }
17341
17342
17343 static PyObject *_wrap_DC_CalcBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
17344     PyObject *resultobj;
17345     wxDC *arg1 = (wxDC *) 0 ;
17346     int arg2 ;
17347     int arg3 ;
17348     PyObject * obj0 = 0 ;
17349     PyObject * obj1 = 0 ;
17350     PyObject * obj2 = 0 ;
17351     char *kwnames[] = {
17352         (char *) "self",(char *) "x",(char *) "y", NULL
17353     };
17354
17355     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CalcBoundingBox",kwnames,&obj0,&obj1,&obj2)) goto fail;
17356     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17357     if (SWIG_arg_fail(1)) SWIG_fail;
17358     {
17359         arg2 = (int)(SWIG_As_int(obj1));
17360         if (SWIG_arg_fail(2)) SWIG_fail;
17361     }
17362     {
17363         arg3 = (int)(SWIG_As_int(obj2));
17364         if (SWIG_arg_fail(3)) SWIG_fail;
17365     }
17366     {
17367         PyThreadState* __tstate = wxPyBeginAllowThreads();
17368         (arg1)->CalcBoundingBox(arg2,arg3);
17369
17370         wxPyEndAllowThreads(__tstate);
17371         if (PyErr_Occurred()) SWIG_fail;
17372     }
17373     Py_INCREF(Py_None); resultobj = Py_None;
17374     return resultobj;
17375     fail:
17376     return NULL;
17377 }
17378
17379
17380 static PyObject *_wrap_DC_CalcBoundingBoxPoint(PyObject *, PyObject *args, PyObject *kwargs) {
17381     PyObject *resultobj;
17382     wxDC *arg1 = (wxDC *) 0 ;
17383     wxPoint *arg2 = 0 ;
17384     wxPoint temp2 ;
17385     PyObject * obj0 = 0 ;
17386     PyObject * obj1 = 0 ;
17387     char *kwnames[] = {
17388         (char *) "self",(char *) "point", NULL
17389     };
17390
17391     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CalcBoundingBoxPoint",kwnames,&obj0,&obj1)) goto fail;
17392     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17393     if (SWIG_arg_fail(1)) SWIG_fail;
17394     {
17395         arg2 = &temp2;
17396         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17397     }
17398     {
17399         PyThreadState* __tstate = wxPyBeginAllowThreads();
17400         wxDC_CalcBoundingBoxPoint(arg1,(wxPoint const &)*arg2);
17401
17402         wxPyEndAllowThreads(__tstate);
17403         if (PyErr_Occurred()) SWIG_fail;
17404     }
17405     Py_INCREF(Py_None); resultobj = Py_None;
17406     return resultobj;
17407     fail:
17408     return NULL;
17409 }
17410
17411
17412 static PyObject *_wrap_DC_ResetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
17413     PyObject *resultobj;
17414     wxDC *arg1 = (wxDC *) 0 ;
17415     PyObject * obj0 = 0 ;
17416     char *kwnames[] = {
17417         (char *) "self", NULL
17418     };
17419
17420     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ResetBoundingBox",kwnames,&obj0)) goto fail;
17421     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17422     if (SWIG_arg_fail(1)) SWIG_fail;
17423     {
17424         PyThreadState* __tstate = wxPyBeginAllowThreads();
17425         (arg1)->ResetBoundingBox();
17426
17427         wxPyEndAllowThreads(__tstate);
17428         if (PyErr_Occurred()) SWIG_fail;
17429     }
17430     Py_INCREF(Py_None); resultobj = Py_None;
17431     return resultobj;
17432     fail:
17433     return NULL;
17434 }
17435
17436
17437 static PyObject *_wrap_DC_MinX(PyObject *, PyObject *args, PyObject *kwargs) {
17438     PyObject *resultobj;
17439     wxDC *arg1 = (wxDC *) 0 ;
17440     int result;
17441     PyObject * obj0 = 0 ;
17442     char *kwnames[] = {
17443         (char *) "self", NULL
17444     };
17445
17446     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinX",kwnames,&obj0)) goto fail;
17447     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17448     if (SWIG_arg_fail(1)) SWIG_fail;
17449     {
17450         PyThreadState* __tstate = wxPyBeginAllowThreads();
17451         result = (int)((wxDC const *)arg1)->MinX();
17452
17453         wxPyEndAllowThreads(__tstate);
17454         if (PyErr_Occurred()) SWIG_fail;
17455     }
17456     {
17457         resultobj = SWIG_From_int((int)(result));
17458     }
17459     return resultobj;
17460     fail:
17461     return NULL;
17462 }
17463
17464
17465 static PyObject *_wrap_DC_MaxX(PyObject *, PyObject *args, PyObject *kwargs) {
17466     PyObject *resultobj;
17467     wxDC *arg1 = (wxDC *) 0 ;
17468     int result;
17469     PyObject * obj0 = 0 ;
17470     char *kwnames[] = {
17471         (char *) "self", NULL
17472     };
17473
17474     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxX",kwnames,&obj0)) goto fail;
17475     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17476     if (SWIG_arg_fail(1)) SWIG_fail;
17477     {
17478         PyThreadState* __tstate = wxPyBeginAllowThreads();
17479         result = (int)((wxDC const *)arg1)->MaxX();
17480
17481         wxPyEndAllowThreads(__tstate);
17482         if (PyErr_Occurred()) SWIG_fail;
17483     }
17484     {
17485         resultobj = SWIG_From_int((int)(result));
17486     }
17487     return resultobj;
17488     fail:
17489     return NULL;
17490 }
17491
17492
17493 static PyObject *_wrap_DC_MinY(PyObject *, PyObject *args, PyObject *kwargs) {
17494     PyObject *resultobj;
17495     wxDC *arg1 = (wxDC *) 0 ;
17496     int result;
17497     PyObject * obj0 = 0 ;
17498     char *kwnames[] = {
17499         (char *) "self", NULL
17500     };
17501
17502     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinY",kwnames,&obj0)) goto fail;
17503     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17504     if (SWIG_arg_fail(1)) SWIG_fail;
17505     {
17506         PyThreadState* __tstate = wxPyBeginAllowThreads();
17507         result = (int)((wxDC const *)arg1)->MinY();
17508
17509         wxPyEndAllowThreads(__tstate);
17510         if (PyErr_Occurred()) SWIG_fail;
17511     }
17512     {
17513         resultobj = SWIG_From_int((int)(result));
17514     }
17515     return resultobj;
17516     fail:
17517     return NULL;
17518 }
17519
17520
17521 static PyObject *_wrap_DC_MaxY(PyObject *, PyObject *args, PyObject *kwargs) {
17522     PyObject *resultobj;
17523     wxDC *arg1 = (wxDC *) 0 ;
17524     int result;
17525     PyObject * obj0 = 0 ;
17526     char *kwnames[] = {
17527         (char *) "self", NULL
17528     };
17529
17530     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxY",kwnames,&obj0)) goto fail;
17531     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17532     if (SWIG_arg_fail(1)) SWIG_fail;
17533     {
17534         PyThreadState* __tstate = wxPyBeginAllowThreads();
17535         result = (int)((wxDC const *)arg1)->MaxY();
17536
17537         wxPyEndAllowThreads(__tstate);
17538         if (PyErr_Occurred()) SWIG_fail;
17539     }
17540     {
17541         resultobj = SWIG_From_int((int)(result));
17542     }
17543     return resultobj;
17544     fail:
17545     return NULL;
17546 }
17547
17548
17549 static PyObject *_wrap_DC_GetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
17550     PyObject *resultobj;
17551     wxDC *arg1 = (wxDC *) 0 ;
17552     int *arg2 = (int *) 0 ;
17553     int *arg3 = (int *) 0 ;
17554     int *arg4 = (int *) 0 ;
17555     int *arg5 = (int *) 0 ;
17556     int temp2 ;
17557     int res2 = 0 ;
17558     int temp3 ;
17559     int res3 = 0 ;
17560     int temp4 ;
17561     int res4 = 0 ;
17562     int temp5 ;
17563     int res5 = 0 ;
17564     PyObject * obj0 = 0 ;
17565     char *kwnames[] = {
17566         (char *) "self", NULL
17567     };
17568
17569     arg2 = &temp2; res2 = SWIG_NEWOBJ;
17570     arg3 = &temp3; res3 = SWIG_NEWOBJ;
17571     arg4 = &temp4; res4 = SWIG_NEWOBJ;
17572     arg5 = &temp5; res5 = SWIG_NEWOBJ;
17573     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBoundingBox",kwnames,&obj0)) goto fail;
17574     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17575     if (SWIG_arg_fail(1)) SWIG_fail;
17576     {
17577         PyThreadState* __tstate = wxPyBeginAllowThreads();
17578         wxDC_GetBoundingBox(arg1,arg2,arg3,arg4,arg5);
17579
17580         wxPyEndAllowThreads(__tstate);
17581         if (PyErr_Occurred()) SWIG_fail;
17582     }
17583     Py_INCREF(Py_None); resultobj = Py_None;
17584     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17585     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
17586     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17587     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
17588     resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
17589     SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
17590     resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
17591     SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
17592     return resultobj;
17593     fail:
17594     return NULL;
17595 }
17596
17597
17598 static PyObject *_wrap_DC_GetHDC(PyObject *, PyObject *args, PyObject *kwargs) {
17599     PyObject *resultobj;
17600     wxDC *arg1 = (wxDC *) 0 ;
17601     long result;
17602     PyObject * obj0 = 0 ;
17603     char *kwnames[] = {
17604         (char *) "self", NULL
17605     };
17606
17607     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetHDC",kwnames,&obj0)) goto fail;
17608     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17609     if (SWIG_arg_fail(1)) SWIG_fail;
17610     {
17611         PyThreadState* __tstate = wxPyBeginAllowThreads();
17612         result = (long)(arg1)->GetHDC();
17613
17614         wxPyEndAllowThreads(__tstate);
17615         if (PyErr_Occurred()) SWIG_fail;
17616     }
17617     {
17618         resultobj = SWIG_From_long((long)(result));
17619     }
17620     return resultobj;
17621     fail:
17622     return NULL;
17623 }
17624
17625
17626 static PyObject *_wrap_DC__DrawPointList(PyObject *, PyObject *args, PyObject *kwargs) {
17627     PyObject *resultobj;
17628     wxDC *arg1 = (wxDC *) 0 ;
17629     PyObject *arg2 = (PyObject *) 0 ;
17630     PyObject *arg3 = (PyObject *) 0 ;
17631     PyObject *arg4 = (PyObject *) 0 ;
17632     PyObject *result;
17633     PyObject * obj0 = 0 ;
17634     PyObject * obj1 = 0 ;
17635     PyObject * obj2 = 0 ;
17636     PyObject * obj3 = 0 ;
17637     char *kwnames[] = {
17638         (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17639     };
17640
17641     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPointList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17642     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17643     if (SWIG_arg_fail(1)) SWIG_fail;
17644     arg2 = obj1;
17645     arg3 = obj2;
17646     arg4 = obj3;
17647     {
17648         PyThreadState* __tstate = wxPyBeginAllowThreads();
17649         result = (PyObject *)wxDC__DrawPointList(arg1,arg2,arg3,arg4);
17650
17651         wxPyEndAllowThreads(__tstate);
17652         if (PyErr_Occurred()) SWIG_fail;
17653     }
17654     resultobj = result;
17655     return resultobj;
17656     fail:
17657     return NULL;
17658 }
17659
17660
17661 static PyObject *_wrap_DC__DrawLineList(PyObject *, PyObject *args, PyObject *kwargs) {
17662     PyObject *resultobj;
17663     wxDC *arg1 = (wxDC *) 0 ;
17664     PyObject *arg2 = (PyObject *) 0 ;
17665     PyObject *arg3 = (PyObject *) 0 ;
17666     PyObject *arg4 = (PyObject *) 0 ;
17667     PyObject *result;
17668     PyObject * obj0 = 0 ;
17669     PyObject * obj1 = 0 ;
17670     PyObject * obj2 = 0 ;
17671     PyObject * obj3 = 0 ;
17672     char *kwnames[] = {
17673         (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17674     };
17675
17676     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawLineList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17677     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17678     if (SWIG_arg_fail(1)) SWIG_fail;
17679     arg2 = obj1;
17680     arg3 = obj2;
17681     arg4 = obj3;
17682     {
17683         PyThreadState* __tstate = wxPyBeginAllowThreads();
17684         result = (PyObject *)wxDC__DrawLineList(arg1,arg2,arg3,arg4);
17685
17686         wxPyEndAllowThreads(__tstate);
17687         if (PyErr_Occurred()) SWIG_fail;
17688     }
17689     resultobj = result;
17690     return resultobj;
17691     fail:
17692     return NULL;
17693 }
17694
17695
17696 static PyObject *_wrap_DC__DrawRectangleList(PyObject *, PyObject *args, PyObject *kwargs) {
17697     PyObject *resultobj;
17698     wxDC *arg1 = (wxDC *) 0 ;
17699     PyObject *arg2 = (PyObject *) 0 ;
17700     PyObject *arg3 = (PyObject *) 0 ;
17701     PyObject *arg4 = (PyObject *) 0 ;
17702     PyObject *result;
17703     PyObject * obj0 = 0 ;
17704     PyObject * obj1 = 0 ;
17705     PyObject * obj2 = 0 ;
17706     PyObject * obj3 = 0 ;
17707     char *kwnames[] = {
17708         (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17709     };
17710
17711     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawRectangleList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17712     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17713     if (SWIG_arg_fail(1)) SWIG_fail;
17714     arg2 = obj1;
17715     arg3 = obj2;
17716     arg4 = obj3;
17717     {
17718         PyThreadState* __tstate = wxPyBeginAllowThreads();
17719         result = (PyObject *)wxDC__DrawRectangleList(arg1,arg2,arg3,arg4);
17720
17721         wxPyEndAllowThreads(__tstate);
17722         if (PyErr_Occurred()) SWIG_fail;
17723     }
17724     resultobj = result;
17725     return resultobj;
17726     fail:
17727     return NULL;
17728 }
17729
17730
17731 static PyObject *_wrap_DC__DrawEllipseList(PyObject *, PyObject *args, PyObject *kwargs) {
17732     PyObject *resultobj;
17733     wxDC *arg1 = (wxDC *) 0 ;
17734     PyObject *arg2 = (PyObject *) 0 ;
17735     PyObject *arg3 = (PyObject *) 0 ;
17736     PyObject *arg4 = (PyObject *) 0 ;
17737     PyObject *result;
17738     PyObject * obj0 = 0 ;
17739     PyObject * obj1 = 0 ;
17740     PyObject * obj2 = 0 ;
17741     PyObject * obj3 = 0 ;
17742     char *kwnames[] = {
17743         (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17744     };
17745
17746     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawEllipseList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17747     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17748     if (SWIG_arg_fail(1)) SWIG_fail;
17749     arg2 = obj1;
17750     arg3 = obj2;
17751     arg4 = obj3;
17752     {
17753         PyThreadState* __tstate = wxPyBeginAllowThreads();
17754         result = (PyObject *)wxDC__DrawEllipseList(arg1,arg2,arg3,arg4);
17755
17756         wxPyEndAllowThreads(__tstate);
17757         if (PyErr_Occurred()) SWIG_fail;
17758     }
17759     resultobj = result;
17760     return resultobj;
17761     fail:
17762     return NULL;
17763 }
17764
17765
17766 static PyObject *_wrap_DC__DrawPolygonList(PyObject *, PyObject *args, PyObject *kwargs) {
17767     PyObject *resultobj;
17768     wxDC *arg1 = (wxDC *) 0 ;
17769     PyObject *arg2 = (PyObject *) 0 ;
17770     PyObject *arg3 = (PyObject *) 0 ;
17771     PyObject *arg4 = (PyObject *) 0 ;
17772     PyObject *result;
17773     PyObject * obj0 = 0 ;
17774     PyObject * obj1 = 0 ;
17775     PyObject * obj2 = 0 ;
17776     PyObject * obj3 = 0 ;
17777     char *kwnames[] = {
17778         (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17779     };
17780
17781     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPolygonList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17782     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17783     if (SWIG_arg_fail(1)) SWIG_fail;
17784     arg2 = obj1;
17785     arg3 = obj2;
17786     arg4 = obj3;
17787     {
17788         PyThreadState* __tstate = wxPyBeginAllowThreads();
17789         result = (PyObject *)wxDC__DrawPolygonList(arg1,arg2,arg3,arg4);
17790
17791         wxPyEndAllowThreads(__tstate);
17792         if (PyErr_Occurred()) SWIG_fail;
17793     }
17794     resultobj = result;
17795     return resultobj;
17796     fail:
17797     return NULL;
17798 }
17799
17800
17801 static PyObject *_wrap_DC__DrawTextList(PyObject *, PyObject *args, PyObject *kwargs) {
17802     PyObject *resultobj;
17803     wxDC *arg1 = (wxDC *) 0 ;
17804     PyObject *arg2 = (PyObject *) 0 ;
17805     PyObject *arg3 = (PyObject *) 0 ;
17806     PyObject *arg4 = (PyObject *) 0 ;
17807     PyObject *arg5 = (PyObject *) 0 ;
17808     PyObject *result;
17809     PyObject * obj0 = 0 ;
17810     PyObject * obj1 = 0 ;
17811     PyObject * obj2 = 0 ;
17812     PyObject * obj3 = 0 ;
17813     PyObject * obj4 = 0 ;
17814     char *kwnames[] = {
17815         (char *) "self",(char *) "textList",(char *) "pyPoints",(char *) "foregroundList",(char *) "backgroundList", NULL
17816     };
17817
17818     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC__DrawTextList",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
17819     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17820     if (SWIG_arg_fail(1)) SWIG_fail;
17821     arg2 = obj1;
17822     arg3 = obj2;
17823     arg4 = obj3;
17824     arg5 = obj4;
17825     {
17826         PyThreadState* __tstate = wxPyBeginAllowThreads();
17827         result = (PyObject *)wxDC__DrawTextList(arg1,arg2,arg3,arg4,arg5);
17828
17829         wxPyEndAllowThreads(__tstate);
17830         if (PyErr_Occurred()) SWIG_fail;
17831     }
17832     resultobj = result;
17833     return resultobj;
17834     fail:
17835     return NULL;
17836 }
17837
17838
17839 static PyObject * DC_swigregister(PyObject *, PyObject *args) {
17840     PyObject *obj;
17841     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17842     SWIG_TypeClientData(SWIGTYPE_p_wxDC, obj);
17843     Py_INCREF(obj);
17844     return Py_BuildValue((char *)"");
17845 }
17846 static PyObject *_wrap_new_MemoryDC(PyObject *, PyObject *args, PyObject *kwargs) {
17847     PyObject *resultobj;
17848     wxMemoryDC *result;
17849     char *kwnames[] = {
17850         NULL
17851     };
17852
17853     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryDC",kwnames)) goto fail;
17854     {
17855         if (!wxPyCheckForApp()) SWIG_fail;
17856         PyThreadState* __tstate = wxPyBeginAllowThreads();
17857         result = (wxMemoryDC *)new wxMemoryDC();
17858
17859         wxPyEndAllowThreads(__tstate);
17860         if (PyErr_Occurred()) SWIG_fail;
17861     }
17862     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17863     return resultobj;
17864     fail:
17865     return NULL;
17866 }
17867
17868
17869 static PyObject *_wrap_new_MemoryDCFromDC(PyObject *, PyObject *args, PyObject *kwargs) {
17870     PyObject *resultobj;
17871     wxDC *arg1 = (wxDC *) 0 ;
17872     wxMemoryDC *result;
17873     PyObject * obj0 = 0 ;
17874     char *kwnames[] = {
17875         (char *) "oldDC", NULL
17876     };
17877
17878     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_MemoryDCFromDC",kwnames,&obj0)) goto fail;
17879     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17880     if (SWIG_arg_fail(1)) SWIG_fail;
17881     {
17882         if (!wxPyCheckForApp()) SWIG_fail;
17883         PyThreadState* __tstate = wxPyBeginAllowThreads();
17884         result = (wxMemoryDC *)new wxMemoryDC(arg1);
17885
17886         wxPyEndAllowThreads(__tstate);
17887         if (PyErr_Occurred()) SWIG_fail;
17888     }
17889     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17890     return resultobj;
17891     fail:
17892     return NULL;
17893 }
17894
17895
17896 static PyObject *_wrap_MemoryDC_SelectObject(PyObject *, PyObject *args, PyObject *kwargs) {
17897     PyObject *resultobj;
17898     wxMemoryDC *arg1 = (wxMemoryDC *) 0 ;
17899     wxBitmap *arg2 = 0 ;
17900     PyObject * obj0 = 0 ;
17901     PyObject * obj1 = 0 ;
17902     char *kwnames[] = {
17903         (char *) "self",(char *) "bitmap", NULL
17904     };
17905
17906     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryDC_SelectObject",kwnames,&obj0,&obj1)) goto fail;
17907     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_EXCEPTION | 0);
17908     if (SWIG_arg_fail(1)) SWIG_fail;
17909     {
17910         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17911         if (SWIG_arg_fail(2)) SWIG_fail;
17912         if (arg2 == NULL) {
17913             SWIG_null_ref("wxBitmap");
17914         }
17915         if (SWIG_arg_fail(2)) SWIG_fail;
17916     }
17917     {
17918         PyThreadState* __tstate = wxPyBeginAllowThreads();
17919         (arg1)->SelectObject((wxBitmap const &)*arg2);
17920
17921         wxPyEndAllowThreads(__tstate);
17922         if (PyErr_Occurred()) SWIG_fail;
17923     }
17924     Py_INCREF(Py_None); resultobj = Py_None;
17925     return resultobj;
17926     fail:
17927     return NULL;
17928 }
17929
17930
17931 static PyObject * MemoryDC_swigregister(PyObject *, PyObject *args) {
17932     PyObject *obj;
17933     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17934     SWIG_TypeClientData(SWIGTYPE_p_wxMemoryDC, obj);
17935     Py_INCREF(obj);
17936     return Py_BuildValue((char *)"");
17937 }
17938 static PyObject *_wrap_new_BufferedDC__SWIG_0(PyObject *, PyObject *args) {
17939     PyObject *resultobj;
17940     wxDC *arg1 = (wxDC *) 0 ;
17941     wxBitmap const &arg2_defvalue = wxNullBitmap ;
17942     wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
17943     int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17944     wxBufferedDC *result;
17945     PyObject * obj0 = 0 ;
17946     PyObject * obj1 = 0 ;
17947     PyObject * obj2 = 0 ;
17948
17949     if(!PyArg_ParseTuple(args,(char *)"O|OO:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
17950     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17951     if (SWIG_arg_fail(1)) SWIG_fail;
17952     if (obj1) {
17953         {
17954             SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17955             if (SWIG_arg_fail(2)) SWIG_fail;
17956             if (arg2 == NULL) {
17957                 SWIG_null_ref("wxBitmap");
17958             }
17959             if (SWIG_arg_fail(2)) SWIG_fail;
17960         }
17961     }
17962     if (obj2) {
17963         {
17964             arg3 = (int)(SWIG_As_int(obj2));
17965             if (SWIG_arg_fail(3)) SWIG_fail;
17966         }
17967     }
17968     {
17969         if (!wxPyCheckForApp()) SWIG_fail;
17970         PyThreadState* __tstate = wxPyBeginAllowThreads();
17971         result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxBitmap const &)*arg2,arg3);
17972
17973         wxPyEndAllowThreads(__tstate);
17974         if (PyErr_Occurred()) SWIG_fail;
17975     }
17976     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17977     return resultobj;
17978     fail:
17979     return NULL;
17980 }
17981
17982
17983 static PyObject *_wrap_new_BufferedDC__SWIG_1(PyObject *, PyObject *args) {
17984     PyObject *resultobj;
17985     wxDC *arg1 = (wxDC *) 0 ;
17986     wxSize *arg2 = 0 ;
17987     int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17988     wxBufferedDC *result;
17989     wxSize temp2 ;
17990     PyObject * obj0 = 0 ;
17991     PyObject * obj1 = 0 ;
17992     PyObject * obj2 = 0 ;
17993
17994     if(!PyArg_ParseTuple(args,(char *)"OO|O:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
17995     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17996     if (SWIG_arg_fail(1)) SWIG_fail;
17997     {
17998         arg2 = &temp2;
17999         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
18000     }
18001     if (obj2) {
18002         {
18003             arg3 = (int)(SWIG_As_int(obj2));
18004             if (SWIG_arg_fail(3)) SWIG_fail;
18005         }
18006     }
18007     {
18008         if (!wxPyCheckForApp()) SWIG_fail;
18009         PyThreadState* __tstate = wxPyBeginAllowThreads();
18010         result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxSize const &)*arg2,arg3);
18011
18012         wxPyEndAllowThreads(__tstate);
18013         if (PyErr_Occurred()) SWIG_fail;
18014     }
18015     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
18016     return resultobj;
18017     fail:
18018     return NULL;
18019 }
18020
18021
18022 static PyObject *_wrap_new_BufferedDC(PyObject *self, PyObject *args) {
18023     int argc;
18024     PyObject *argv[4];
18025     int ii;
18026
18027     argc = PyObject_Length(args);
18028     for (ii = 0; (ii < argc) && (ii < 3); ii++) {
18029         argv[ii] = PyTuple_GetItem(args,ii);
18030     }
18031     if ((argc >= 1) && (argc <= 3)) {
18032         int _v;
18033         {
18034             void *ptr;
18035             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
18036                 _v = 0;
18037                 PyErr_Clear();
18038             } else {
18039                 _v = 1;
18040             }
18041         }
18042         if (_v) {
18043             if (argc <= 1) {
18044                 return _wrap_new_BufferedDC__SWIG_0(self,args);
18045             }
18046             {
18047                 void *ptr = 0;
18048                 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxBitmap, 0) == -1) {
18049                     _v = 0;
18050                     PyErr_Clear();
18051                 } else {
18052                     _v = (ptr != 0);
18053                 }
18054             }
18055             if (_v) {
18056                 if (argc <= 2) {
18057                     return _wrap_new_BufferedDC__SWIG_0(self,args);
18058                 }
18059                 _v = SWIG_Check_int(argv[2]);
18060                 if (_v) {
18061                     return _wrap_new_BufferedDC__SWIG_0(self,args);
18062                 }
18063             }
18064         }
18065     }
18066     if ((argc >= 2) && (argc <= 3)) {
18067         int _v;
18068         {
18069             void *ptr;
18070             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
18071                 _v = 0;
18072                 PyErr_Clear();
18073             } else {
18074                 _v = 1;
18075             }
18076         }
18077         if (_v) {
18078             {
18079                 _v = wxPySimple_typecheck(argv[1], wxT("wxSize"), 2);
18080             }
18081             if (_v) {
18082                 if (argc <= 2) {
18083                     return _wrap_new_BufferedDC__SWIG_1(self,args);
18084                 }
18085                 _v = SWIG_Check_int(argv[2]);
18086                 if (_v) {
18087                     return _wrap_new_BufferedDC__SWIG_1(self,args);
18088                 }
18089             }
18090         }
18091     }
18092
18093     PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_BufferedDC'");
18094     return NULL;
18095 }
18096
18097
18098 static PyObject *_wrap_delete_BufferedDC(PyObject *, PyObject *args, PyObject *kwargs) {
18099     PyObject *resultobj;
18100     wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
18101     PyObject * obj0 = 0 ;
18102     char *kwnames[] = {
18103         (char *) "self", NULL
18104     };
18105
18106     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BufferedDC",kwnames,&obj0)) goto fail;
18107     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
18108     if (SWIG_arg_fail(1)) SWIG_fail;
18109     {
18110         PyThreadState* __tstate = wxPyBeginAllowThreads();
18111         delete arg1;
18112
18113         wxPyEndAllowThreads(__tstate);
18114         if (PyErr_Occurred()) SWIG_fail;
18115     }
18116     Py_INCREF(Py_None); resultobj = Py_None;
18117     return resultobj;
18118     fail:
18119     return NULL;
18120 }
18121
18122
18123 static PyObject *_wrap_BufferedDC_UnMask(PyObject *, PyObject *args, PyObject *kwargs) {
18124     PyObject *resultobj;
18125     wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
18126     PyObject * obj0 = 0 ;
18127     char *kwnames[] = {
18128         (char *) "self", NULL
18129     };
18130
18131     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BufferedDC_UnMask",kwnames,&obj0)) goto fail;
18132     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
18133     if (SWIG_arg_fail(1)) SWIG_fail;
18134     {
18135         PyThreadState* __tstate = wxPyBeginAllowThreads();
18136         (arg1)->UnMask();
18137
18138         wxPyEndAllowThreads(__tstate);
18139         if (PyErr_Occurred()) SWIG_fail;
18140     }
18141     Py_INCREF(Py_None); resultobj = Py_None;
18142     return resultobj;
18143     fail:
18144     return NULL;
18145 }
18146
18147
18148 static PyObject * BufferedDC_swigregister(PyObject *, PyObject *args) {
18149     PyObject *obj;
18150     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18151     SWIG_TypeClientData(SWIGTYPE_p_wxBufferedDC, obj);
18152     Py_INCREF(obj);
18153     return Py_BuildValue((char *)"");
18154 }
18155 static PyObject *_wrap_new_BufferedPaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
18156     PyObject *resultobj;
18157     wxWindow *arg1 = (wxWindow *) 0 ;
18158     wxBitmap const &arg2_defvalue = wxNullBitmap ;
18159     wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
18160     int arg3 = (int) wxBUFFER_CLIENT_AREA ;
18161     wxBufferedPaintDC *result;
18162     PyObject * obj0 = 0 ;
18163     PyObject * obj1 = 0 ;
18164     PyObject * obj2 = 0 ;
18165     char *kwnames[] = {
18166         (char *) "window",(char *) "buffer",(char *) "style", NULL
18167     };
18168
18169     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_BufferedPaintDC",kwnames,&obj0,&obj1,&obj2)) goto fail;
18170     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18171     if (SWIG_arg_fail(1)) SWIG_fail;
18172     if (obj1) {
18173         {
18174             SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18175             if (SWIG_arg_fail(2)) SWIG_fail;
18176             if (arg2 == NULL) {
18177                 SWIG_null_ref("wxBitmap");
18178             }
18179             if (SWIG_arg_fail(2)) SWIG_fail;
18180         }
18181     }
18182     if (obj2) {
18183         {
18184             arg3 = (int)(SWIG_As_int(obj2));
18185             if (SWIG_arg_fail(3)) SWIG_fail;
18186         }
18187     }
18188     {
18189         if (!wxPyCheckForApp()) SWIG_fail;
18190         PyThreadState* __tstate = wxPyBeginAllowThreads();
18191         result = (wxBufferedPaintDC *)new wxBufferedPaintDC(arg1,(wxBitmap const &)*arg2,arg3);
18192
18193         wxPyEndAllowThreads(__tstate);
18194         if (PyErr_Occurred()) SWIG_fail;
18195     }
18196     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedPaintDC, 1);
18197     return resultobj;
18198     fail:
18199     return NULL;
18200 }
18201
18202
18203 static PyObject * BufferedPaintDC_swigregister(PyObject *, PyObject *args) {
18204     PyObject *obj;
18205     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18206     SWIG_TypeClientData(SWIGTYPE_p_wxBufferedPaintDC, obj);
18207     Py_INCREF(obj);
18208     return Py_BuildValue((char *)"");
18209 }
18210 static PyObject *_wrap_new_ScreenDC(PyObject *, PyObject *args, PyObject *kwargs) {
18211     PyObject *resultobj;
18212     wxScreenDC *result;
18213     char *kwnames[] = {
18214         NULL
18215     };
18216
18217     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ScreenDC",kwnames)) goto fail;
18218     {
18219         if (!wxPyCheckForApp()) SWIG_fail;
18220         PyThreadState* __tstate = wxPyBeginAllowThreads();
18221         result = (wxScreenDC *)new wxScreenDC();
18222
18223         wxPyEndAllowThreads(__tstate);
18224         if (PyErr_Occurred()) SWIG_fail;
18225     }
18226     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScreenDC, 1);
18227     return resultobj;
18228     fail:
18229     return NULL;
18230 }
18231
18232
18233 static PyObject *_wrap_ScreenDC_StartDrawingOnTopWin(PyObject *, PyObject *args, PyObject *kwargs) {
18234     PyObject *resultobj;
18235     wxScreenDC *arg1 = (wxScreenDC *) 0 ;
18236     wxWindow *arg2 = (wxWindow *) 0 ;
18237     bool result;
18238     PyObject * obj0 = 0 ;
18239     PyObject * obj1 = 0 ;
18240     char *kwnames[] = {
18241         (char *) "self",(char *) "window", NULL
18242     };
18243
18244     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScreenDC_StartDrawingOnTopWin",kwnames,&obj0,&obj1)) goto fail;
18245     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
18246     if (SWIG_arg_fail(1)) SWIG_fail;
18247     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18248     if (SWIG_arg_fail(2)) SWIG_fail;
18249     {
18250         PyThreadState* __tstate = wxPyBeginAllowThreads();
18251         result = (bool)(arg1)->StartDrawingOnTop(arg2);
18252
18253         wxPyEndAllowThreads(__tstate);
18254         if (PyErr_Occurred()) SWIG_fail;
18255     }
18256     {
18257         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18258     }
18259     return resultobj;
18260     fail:
18261     return NULL;
18262 }
18263
18264
18265 static PyObject *_wrap_ScreenDC_StartDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
18266     PyObject *resultobj;
18267     wxScreenDC *arg1 = (wxScreenDC *) 0 ;
18268     wxRect *arg2 = (wxRect *) NULL ;
18269     bool result;
18270     PyObject * obj0 = 0 ;
18271     PyObject * obj1 = 0 ;
18272     char *kwnames[] = {
18273         (char *) "self",(char *) "rect", NULL
18274     };
18275
18276     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ScreenDC_StartDrawingOnTop",kwnames,&obj0,&obj1)) goto fail;
18277     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
18278     if (SWIG_arg_fail(1)) SWIG_fail;
18279     if (obj1) {
18280         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
18281         if (SWIG_arg_fail(2)) SWIG_fail;
18282     }
18283     {
18284         PyThreadState* __tstate = wxPyBeginAllowThreads();
18285         result = (bool)(arg1)->StartDrawingOnTop(arg2);
18286
18287         wxPyEndAllowThreads(__tstate);
18288         if (PyErr_Occurred()) SWIG_fail;
18289     }
18290     {
18291         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18292     }
18293     return resultobj;
18294     fail:
18295     return NULL;
18296 }
18297
18298
18299 static PyObject *_wrap_ScreenDC_EndDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
18300     PyObject *resultobj;
18301     wxScreenDC *arg1 = (wxScreenDC *) 0 ;
18302     bool result;
18303     PyObject * obj0 = 0 ;
18304     char *kwnames[] = {
18305         (char *) "self", NULL
18306     };
18307
18308     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScreenDC_EndDrawingOnTop",kwnames,&obj0)) goto fail;
18309     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
18310     if (SWIG_arg_fail(1)) SWIG_fail;
18311     {
18312         PyThreadState* __tstate = wxPyBeginAllowThreads();
18313         result = (bool)(arg1)->EndDrawingOnTop();
18314
18315         wxPyEndAllowThreads(__tstate);
18316         if (PyErr_Occurred()) SWIG_fail;
18317     }
18318     {
18319         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18320     }
18321     return resultobj;
18322     fail:
18323     return NULL;
18324 }
18325
18326
18327 static PyObject * ScreenDC_swigregister(PyObject *, PyObject *args) {
18328     PyObject *obj;
18329     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18330     SWIG_TypeClientData(SWIGTYPE_p_wxScreenDC, obj);
18331     Py_INCREF(obj);
18332     return Py_BuildValue((char *)"");
18333 }
18334 static PyObject *_wrap_new_ClientDC(PyObject *, PyObject *args, PyObject *kwargs) {
18335     PyObject *resultobj;
18336     wxWindow *arg1 = (wxWindow *) 0 ;
18337     wxClientDC *result;
18338     PyObject * obj0 = 0 ;
18339     char *kwnames[] = {
18340         (char *) "win", NULL
18341     };
18342
18343     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ClientDC",kwnames,&obj0)) goto fail;
18344     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18345     if (SWIG_arg_fail(1)) SWIG_fail;
18346     {
18347         if (!wxPyCheckForApp()) SWIG_fail;
18348         PyThreadState* __tstate = wxPyBeginAllowThreads();
18349         result = (wxClientDC *)new wxClientDC(arg1);
18350
18351         wxPyEndAllowThreads(__tstate);
18352         if (PyErr_Occurred()) SWIG_fail;
18353     }
18354     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClientDC, 1);
18355     return resultobj;
18356     fail:
18357     return NULL;
18358 }
18359
18360
18361 static PyObject * ClientDC_swigregister(PyObject *, PyObject *args) {
18362     PyObject *obj;
18363     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18364     SWIG_TypeClientData(SWIGTYPE_p_wxClientDC, obj);
18365     Py_INCREF(obj);
18366     return Py_BuildValue((char *)"");
18367 }
18368 static PyObject *_wrap_new_PaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
18369     PyObject *resultobj;
18370     wxWindow *arg1 = (wxWindow *) 0 ;
18371     wxPaintDC *result;
18372     PyObject * obj0 = 0 ;
18373     char *kwnames[] = {
18374         (char *) "win", NULL
18375     };
18376
18377     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PaintDC",kwnames,&obj0)) goto fail;
18378     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18379     if (SWIG_arg_fail(1)) SWIG_fail;
18380     {
18381         if (!wxPyCheckForApp()) SWIG_fail;
18382         PyThreadState* __tstate = wxPyBeginAllowThreads();
18383         result = (wxPaintDC *)new wxPaintDC(arg1);
18384
18385         wxPyEndAllowThreads(__tstate);
18386         if (PyErr_Occurred()) SWIG_fail;
18387     }
18388     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintDC, 1);
18389     return resultobj;
18390     fail:
18391     return NULL;
18392 }
18393
18394
18395 static PyObject * PaintDC_swigregister(PyObject *, PyObject *args) {
18396     PyObject *obj;
18397     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18398     SWIG_TypeClientData(SWIGTYPE_p_wxPaintDC, obj);
18399     Py_INCREF(obj);
18400     return Py_BuildValue((char *)"");
18401 }
18402 static PyObject *_wrap_new_WindowDC(PyObject *, PyObject *args, PyObject *kwargs) {
18403     PyObject *resultobj;
18404     wxWindow *arg1 = (wxWindow *) 0 ;
18405     wxWindowDC *result;
18406     PyObject * obj0 = 0 ;
18407     char *kwnames[] = {
18408         (char *) "win", NULL
18409     };
18410
18411     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_WindowDC",kwnames,&obj0)) goto fail;
18412     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18413     if (SWIG_arg_fail(1)) SWIG_fail;
18414     {
18415         if (!wxPyCheckForApp()) SWIG_fail;
18416         PyThreadState* __tstate = wxPyBeginAllowThreads();
18417         result = (wxWindowDC *)new wxWindowDC(arg1);
18418
18419         wxPyEndAllowThreads(__tstate);
18420         if (PyErr_Occurred()) SWIG_fail;
18421     }
18422     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDC, 1);
18423     return resultobj;
18424     fail:
18425     return NULL;
18426 }
18427
18428
18429 static PyObject * WindowDC_swigregister(PyObject *, PyObject *args) {
18430     PyObject *obj;
18431     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18432     SWIG_TypeClientData(SWIGTYPE_p_wxWindowDC, obj);
18433     Py_INCREF(obj);
18434     return Py_BuildValue((char *)"");
18435 }
18436 static PyObject *_wrap_new_MirrorDC(PyObject *, PyObject *args, PyObject *kwargs) {
18437     PyObject *resultobj;
18438     wxDC *arg1 = 0 ;
18439     bool arg2 ;
18440     wxMirrorDC *result;
18441     PyObject * obj0 = 0 ;
18442     PyObject * obj1 = 0 ;
18443     char *kwnames[] = {
18444         (char *) "dc",(char *) "mirror", NULL
18445     };
18446
18447     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_MirrorDC",kwnames,&obj0,&obj1)) goto fail;
18448     {
18449         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18450         if (SWIG_arg_fail(1)) SWIG_fail;
18451         if (arg1 == NULL) {
18452             SWIG_null_ref("wxDC");
18453         }
18454         if (SWIG_arg_fail(1)) SWIG_fail;
18455     }
18456     {
18457         arg2 = (bool)(SWIG_As_bool(obj1));
18458         if (SWIG_arg_fail(2)) SWIG_fail;
18459     }
18460     {
18461         if (!wxPyCheckForApp()) SWIG_fail;
18462         PyThreadState* __tstate = wxPyBeginAllowThreads();
18463         result = (wxMirrorDC *)new wxMirrorDC(*arg1,arg2);
18464
18465         wxPyEndAllowThreads(__tstate);
18466         if (PyErr_Occurred()) SWIG_fail;
18467     }
18468     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMirrorDC, 1);
18469     return resultobj;
18470     fail:
18471     return NULL;
18472 }
18473
18474
18475 static PyObject * MirrorDC_swigregister(PyObject *, PyObject *args) {
18476     PyObject *obj;
18477     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18478     SWIG_TypeClientData(SWIGTYPE_p_wxMirrorDC, obj);
18479     Py_INCREF(obj);
18480     return Py_BuildValue((char *)"");
18481 }
18482 static PyObject *_wrap_new_PostScriptDC(PyObject *, PyObject *args, PyObject *kwargs) {
18483     PyObject *resultobj;
18484     wxPrintData *arg1 = 0 ;
18485     wxPostScriptDC *result;
18486     PyObject * obj0 = 0 ;
18487     char *kwnames[] = {
18488         (char *) "printData", NULL
18489     };
18490
18491     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PostScriptDC",kwnames,&obj0)) goto fail;
18492     {
18493         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18494         if (SWIG_arg_fail(1)) SWIG_fail;
18495         if (arg1 == NULL) {
18496             SWIG_null_ref("wxPrintData");
18497         }
18498         if (SWIG_arg_fail(1)) SWIG_fail;
18499     }
18500     {
18501         if (!wxPyCheckForApp()) SWIG_fail;
18502         PyThreadState* __tstate = wxPyBeginAllowThreads();
18503         result = (wxPostScriptDC *)new wxPostScriptDC((wxPrintData const &)*arg1);
18504
18505         wxPyEndAllowThreads(__tstate);
18506         if (PyErr_Occurred()) SWIG_fail;
18507     }
18508     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPostScriptDC, 1);
18509     return resultobj;
18510     fail:
18511     return NULL;
18512 }
18513
18514
18515 static PyObject *_wrap_PostScriptDC_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
18516     PyObject *resultobj;
18517     wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
18518     wxPrintData *result;
18519     PyObject * obj0 = 0 ;
18520     char *kwnames[] = {
18521         (char *) "self", NULL
18522     };
18523
18524     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_GetPrintData",kwnames,&obj0)) goto fail;
18525     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
18526     if (SWIG_arg_fail(1)) SWIG_fail;
18527     {
18528         PyThreadState* __tstate = wxPyBeginAllowThreads();
18529         {
18530             wxPrintData &_result_ref = (arg1)->GetPrintData();
18531             result = (wxPrintData *) &_result_ref;
18532         }
18533
18534         wxPyEndAllowThreads(__tstate);
18535         if (PyErr_Occurred()) SWIG_fail;
18536     }
18537     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
18538     return resultobj;
18539     fail:
18540     return NULL;
18541 }
18542
18543
18544 static PyObject *_wrap_PostScriptDC_SetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
18545     PyObject *resultobj;
18546     wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
18547     wxPrintData *arg2 = 0 ;
18548     PyObject * obj0 = 0 ;
18549     PyObject * obj1 = 0 ;
18550     char *kwnames[] = {
18551         (char *) "self",(char *) "data", NULL
18552     };
18553
18554     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostScriptDC_SetPrintData",kwnames,&obj0,&obj1)) goto fail;
18555     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
18556     if (SWIG_arg_fail(1)) SWIG_fail;
18557     {
18558         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18559         if (SWIG_arg_fail(2)) SWIG_fail;
18560         if (arg2 == NULL) {
18561             SWIG_null_ref("wxPrintData");
18562         }
18563         if (SWIG_arg_fail(2)) SWIG_fail;
18564     }
18565     {
18566         PyThreadState* __tstate = wxPyBeginAllowThreads();
18567         (arg1)->SetPrintData((wxPrintData const &)*arg2);
18568
18569         wxPyEndAllowThreads(__tstate);
18570         if (PyErr_Occurred()) SWIG_fail;
18571     }
18572     Py_INCREF(Py_None); resultobj = Py_None;
18573     return resultobj;
18574     fail:
18575     return NULL;
18576 }
18577
18578
18579 static PyObject *_wrap_PostScriptDC_SetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
18580     PyObject *resultobj;
18581     int arg1 ;
18582     PyObject * obj0 = 0 ;
18583     char *kwnames[] = {
18584         (char *) "ppi", NULL
18585     };
18586
18587     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_SetResolution",kwnames,&obj0)) goto fail;
18588     {
18589         arg1 = (int)(SWIG_As_int(obj0));
18590         if (SWIG_arg_fail(1)) SWIG_fail;
18591     }
18592     {
18593         PyThreadState* __tstate = wxPyBeginAllowThreads();
18594         wxPostScriptDC::SetResolution(arg1);
18595
18596         wxPyEndAllowThreads(__tstate);
18597         if (PyErr_Occurred()) SWIG_fail;
18598     }
18599     Py_INCREF(Py_None); resultobj = Py_None;
18600     return resultobj;
18601     fail:
18602     return NULL;
18603 }
18604
18605
18606 static PyObject *_wrap_PostScriptDC_GetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
18607     PyObject *resultobj;
18608     int result;
18609     char *kwnames[] = {
18610         NULL
18611     };
18612
18613     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PostScriptDC_GetResolution",kwnames)) goto fail;
18614     {
18615         PyThreadState* __tstate = wxPyBeginAllowThreads();
18616         result = (int)wxPostScriptDC::GetResolution();
18617
18618         wxPyEndAllowThreads(__tstate);
18619         if (PyErr_Occurred()) SWIG_fail;
18620     }
18621     {
18622         resultobj = SWIG_From_int((int)(result));
18623     }
18624     return resultobj;
18625     fail:
18626     return NULL;
18627 }
18628
18629
18630 static PyObject * PostScriptDC_swigregister(PyObject *, PyObject *args) {
18631     PyObject *obj;
18632     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18633     SWIG_TypeClientData(SWIGTYPE_p_wxPostScriptDC, obj);
18634     Py_INCREF(obj);
18635     return Py_BuildValue((char *)"");
18636 }
18637 static PyObject *_wrap_new_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
18638     PyObject *resultobj;
18639     wxString const &arg1_defvalue = wxPyEmptyString ;
18640     wxString *arg1 = (wxString *) &arg1_defvalue ;
18641     wxMetaFile *result;
18642     bool temp1 = false ;
18643     PyObject * obj0 = 0 ;
18644     char *kwnames[] = {
18645         (char *) "filename", NULL
18646     };
18647
18648     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MetaFile",kwnames,&obj0)) goto fail;
18649     if (obj0) {
18650         {
18651             arg1 = wxString_in_helper(obj0);
18652             if (arg1 == NULL) SWIG_fail;
18653             temp1 = true;
18654         }
18655     }
18656     {
18657         if (!wxPyCheckForApp()) SWIG_fail;
18658         PyThreadState* __tstate = wxPyBeginAllowThreads();
18659         result = (wxMetaFile *)new wxMetaFile((wxString const &)*arg1);
18660
18661         wxPyEndAllowThreads(__tstate);
18662         if (PyErr_Occurred()) SWIG_fail;
18663     }
18664     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 1);
18665     {
18666         if (temp1)
18667         delete arg1;
18668     }
18669     return resultobj;
18670     fail:
18671     {
18672         if (temp1)
18673         delete arg1;
18674     }
18675     return NULL;
18676 }
18677
18678
18679 static PyObject *_wrap_delete_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
18680     PyObject *resultobj;
18681     wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18682     PyObject * obj0 = 0 ;
18683     char *kwnames[] = {
18684         (char *) "self", NULL
18685     };
18686
18687     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MetaFile",kwnames,&obj0)) goto fail;
18688     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18689     if (SWIG_arg_fail(1)) SWIG_fail;
18690     {
18691         PyThreadState* __tstate = wxPyBeginAllowThreads();
18692         delete arg1;
18693
18694         wxPyEndAllowThreads(__tstate);
18695         if (PyErr_Occurred()) SWIG_fail;
18696     }
18697     Py_INCREF(Py_None); resultobj = Py_None;
18698     return resultobj;
18699     fail:
18700     return NULL;
18701 }
18702
18703
18704 static PyObject *_wrap_MetaFile_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
18705     PyObject *resultobj;
18706     wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18707     bool result;
18708     PyObject * obj0 = 0 ;
18709     char *kwnames[] = {
18710         (char *) "self", NULL
18711     };
18712
18713     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_Ok",kwnames,&obj0)) goto fail;
18714     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18715     if (SWIG_arg_fail(1)) SWIG_fail;
18716     {
18717         PyThreadState* __tstate = wxPyBeginAllowThreads();
18718         result = (bool)(arg1)->Ok();
18719
18720         wxPyEndAllowThreads(__tstate);
18721         if (PyErr_Occurred()) SWIG_fail;
18722     }
18723     {
18724         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18725     }
18726     return resultobj;
18727     fail:
18728     return NULL;
18729 }
18730
18731
18732 static PyObject *_wrap_MetaFile_SetClipboard(PyObject *, PyObject *args, PyObject *kwargs) {
18733     PyObject *resultobj;
18734     wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18735     int arg2 = (int) 0 ;
18736     int arg3 = (int) 0 ;
18737     bool result;
18738     PyObject * obj0 = 0 ;
18739     PyObject * obj1 = 0 ;
18740     PyObject * obj2 = 0 ;
18741     char *kwnames[] = {
18742         (char *) "self",(char *) "width",(char *) "height", NULL
18743     };
18744
18745     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MetaFile_SetClipboard",kwnames,&obj0,&obj1,&obj2)) goto fail;
18746     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18747     if (SWIG_arg_fail(1)) SWIG_fail;
18748     if (obj1) {
18749         {
18750             arg2 = (int)(SWIG_As_int(obj1));
18751             if (SWIG_arg_fail(2)) SWIG_fail;
18752         }
18753     }
18754     if (obj2) {
18755         {
18756             arg3 = (int)(SWIG_As_int(obj2));
18757             if (SWIG_arg_fail(3)) SWIG_fail;
18758         }
18759     }
18760     {
18761         PyThreadState* __tstate = wxPyBeginAllowThreads();
18762         result = (bool)(arg1)->SetClipboard(arg2,arg3);
18763
18764         wxPyEndAllowThreads(__tstate);
18765         if (PyErr_Occurred()) SWIG_fail;
18766     }
18767     {
18768         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18769     }
18770     return resultobj;
18771     fail:
18772     return NULL;
18773 }
18774
18775
18776 static PyObject *_wrap_MetaFile_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18777     PyObject *resultobj;
18778     wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18779     wxSize result;
18780     PyObject * obj0 = 0 ;
18781     char *kwnames[] = {
18782         (char *) "self", NULL
18783     };
18784
18785     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetSize",kwnames,&obj0)) goto fail;
18786     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18787     if (SWIG_arg_fail(1)) SWIG_fail;
18788     {
18789         PyThreadState* __tstate = wxPyBeginAllowThreads();
18790         result = (arg1)->GetSize();
18791
18792         wxPyEndAllowThreads(__tstate);
18793         if (PyErr_Occurred()) SWIG_fail;
18794     }
18795     {
18796         wxSize * resultptr;
18797         resultptr = new wxSize((wxSize &)(result));
18798         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18799     }
18800     return resultobj;
18801     fail:
18802     return NULL;
18803 }
18804
18805
18806 static PyObject *_wrap_MetaFile_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
18807     PyObject *resultobj;
18808     wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18809     int result;
18810     PyObject * obj0 = 0 ;
18811     char *kwnames[] = {
18812         (char *) "self", NULL
18813     };
18814
18815     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetWidth",kwnames,&obj0)) goto fail;
18816     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18817     if (SWIG_arg_fail(1)) SWIG_fail;
18818     {
18819         PyThreadState* __tstate = wxPyBeginAllowThreads();
18820         result = (int)(arg1)->GetWidth();
18821
18822         wxPyEndAllowThreads(__tstate);
18823         if (PyErr_Occurred()) SWIG_fail;
18824     }
18825     {
18826         resultobj = SWIG_From_int((int)(result));
18827     }
18828     return resultobj;
18829     fail:
18830     return NULL;
18831 }
18832
18833
18834 static PyObject *_wrap_MetaFile_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
18835     PyObject *resultobj;
18836     wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18837     int result;
18838     PyObject * obj0 = 0 ;
18839     char *kwnames[] = {
18840         (char *) "self", NULL
18841     };
18842
18843     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetHeight",kwnames,&obj0)) goto fail;
18844     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18845     if (SWIG_arg_fail(1)) SWIG_fail;
18846     {
18847         PyThreadState* __tstate = wxPyBeginAllowThreads();
18848         result = (int)(arg1)->GetHeight();
18849
18850         wxPyEndAllowThreads(__tstate);
18851         if (PyErr_Occurred()) SWIG_fail;
18852     }
18853     {
18854         resultobj = SWIG_From_int((int)(result));
18855     }
18856     return resultobj;
18857     fail:
18858     return NULL;
18859 }
18860
18861
18862 static PyObject *_wrap_MetaFile_GetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
18863     PyObject *resultobj;
18864     wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18865     wxString *result;
18866     PyObject * obj0 = 0 ;
18867     char *kwnames[] = {
18868         (char *) "self", NULL
18869     };
18870
18871     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetFileName",kwnames,&obj0)) goto fail;
18872     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18873     if (SWIG_arg_fail(1)) SWIG_fail;
18874     {
18875         PyThreadState* __tstate = wxPyBeginAllowThreads();
18876         {
18877             wxString const &_result_ref = ((wxMetaFile const *)arg1)->GetFileName();
18878             result = (wxString *) &_result_ref;
18879         }
18880
18881         wxPyEndAllowThreads(__tstate);
18882         if (PyErr_Occurred()) SWIG_fail;
18883     }
18884     {
18885 #if wxUSE_UNICODE
18886         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18887 #else
18888         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18889 #endif
18890     }
18891     return resultobj;
18892     fail:
18893     return NULL;
18894 }
18895
18896
18897 static PyObject * MetaFile_swigregister(PyObject *, PyObject *args) {
18898     PyObject *obj;
18899     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18900     SWIG_TypeClientData(SWIGTYPE_p_wxMetaFile, obj);
18901     Py_INCREF(obj);
18902     return Py_BuildValue((char *)"");
18903 }
18904 static PyObject *_wrap_new_MetaFileDC(PyObject *, PyObject *args, PyObject *kwargs) {
18905     PyObject *resultobj;
18906     wxString const &arg1_defvalue = wxPyEmptyString ;
18907     wxString *arg1 = (wxString *) &arg1_defvalue ;
18908     int arg2 = (int) 0 ;
18909     int arg3 = (int) 0 ;
18910     wxString const &arg4_defvalue = wxPyEmptyString ;
18911     wxString *arg4 = (wxString *) &arg4_defvalue ;
18912     wxMetaFileDC *result;
18913     bool temp1 = false ;
18914     bool temp4 = false ;
18915     PyObject * obj0 = 0 ;
18916     PyObject * obj1 = 0 ;
18917     PyObject * obj2 = 0 ;
18918     PyObject * obj3 = 0 ;
18919     char *kwnames[] = {
18920         (char *) "filename",(char *) "width",(char *) "height",(char *) "description", NULL
18921     };
18922
18923     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_MetaFileDC",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18924     if (obj0) {
18925         {
18926             arg1 = wxString_in_helper(obj0);
18927             if (arg1 == NULL) SWIG_fail;
18928             temp1 = true;
18929         }
18930     }
18931     if (obj1) {
18932         {
18933             arg2 = (int)(SWIG_As_int(obj1));
18934             if (SWIG_arg_fail(2)) SWIG_fail;
18935         }
18936     }
18937     if (obj2) {
18938         {
18939             arg3 = (int)(SWIG_As_int(obj2));
18940             if (SWIG_arg_fail(3)) SWIG_fail;
18941         }
18942     }
18943     if (obj3) {
18944         {
18945             arg4 = wxString_in_helper(obj3);
18946             if (arg4 == NULL) SWIG_fail;
18947             temp4 = true;
18948         }
18949     }
18950     {
18951         if (!wxPyCheckForApp()) SWIG_fail;
18952         PyThreadState* __tstate = wxPyBeginAllowThreads();
18953         result = (wxMetaFileDC *)new wxMetaFileDC((wxString const &)*arg1,arg2,arg3,(wxString const &)*arg4);
18954
18955         wxPyEndAllowThreads(__tstate);
18956         if (PyErr_Occurred()) SWIG_fail;
18957     }
18958     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFileDC, 1);
18959     {
18960         if (temp1)
18961         delete arg1;
18962     }
18963     {
18964         if (temp4)
18965         delete arg4;
18966     }
18967     return resultobj;
18968     fail:
18969     {
18970         if (temp1)
18971         delete arg1;
18972     }
18973     {
18974         if (temp4)
18975         delete arg4;
18976     }
18977     return NULL;
18978 }
18979
18980
18981 static PyObject *_wrap_MetaFileDC_Close(PyObject *, PyObject *args, PyObject *kwargs) {
18982     PyObject *resultobj;
18983     wxMetaFileDC *arg1 = (wxMetaFileDC *) 0 ;
18984     wxMetaFile *result;
18985     PyObject * obj0 = 0 ;
18986     char *kwnames[] = {
18987         (char *) "self", NULL
18988     };
18989
18990     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFileDC_Close",kwnames,&obj0)) goto fail;
18991     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFileDC, SWIG_POINTER_EXCEPTION | 0);
18992     if (SWIG_arg_fail(1)) SWIG_fail;
18993     {
18994         PyThreadState* __tstate = wxPyBeginAllowThreads();
18995         result = (wxMetaFile *)(arg1)->Close();
18996
18997         wxPyEndAllowThreads(__tstate);
18998         if (PyErr_Occurred()) SWIG_fail;
18999     }
19000     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 0);
19001     return resultobj;
19002     fail:
19003     return NULL;
19004 }
19005
19006
19007 static PyObject * MetaFileDC_swigregister(PyObject *, PyObject *args) {
19008     PyObject *obj;
19009     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19010     SWIG_TypeClientData(SWIGTYPE_p_wxMetaFileDC, obj);
19011     Py_INCREF(obj);
19012     return Py_BuildValue((char *)"");
19013 }
19014 static PyObject *_wrap_new_PrinterDC(PyObject *, PyObject *args, PyObject *kwargs) {
19015     PyObject *resultobj;
19016     wxPrintData *arg1 = 0 ;
19017     wxPrinterDC *result;
19018     PyObject * obj0 = 0 ;
19019     char *kwnames[] = {
19020         (char *) "printData", NULL
19021     };
19022
19023     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PrinterDC",kwnames,&obj0)) goto fail;
19024     {
19025         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
19026         if (SWIG_arg_fail(1)) SWIG_fail;
19027         if (arg1 == NULL) {
19028             SWIG_null_ref("wxPrintData");
19029         }
19030         if (SWIG_arg_fail(1)) SWIG_fail;
19031     }
19032     {
19033         if (!wxPyCheckForApp()) SWIG_fail;
19034         PyThreadState* __tstate = wxPyBeginAllowThreads();
19035         result = (wxPrinterDC *)new wxPrinterDC((wxPrintData const &)*arg1);
19036
19037         wxPyEndAllowThreads(__tstate);
19038         if (PyErr_Occurred()) SWIG_fail;
19039     }
19040     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrinterDC, 1);
19041     return resultobj;
19042     fail:
19043     return NULL;
19044 }
19045
19046
19047 static PyObject * PrinterDC_swigregister(PyObject *, PyObject *args) {
19048     PyObject *obj;
19049     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19050     SWIG_TypeClientData(SWIGTYPE_p_wxPrinterDC, obj);
19051     Py_INCREF(obj);
19052     return Py_BuildValue((char *)"");
19053 }
19054 static PyObject *_wrap_new_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
19055     PyObject *resultobj;
19056     int arg1 ;
19057     int arg2 ;
19058     int arg3 = (int) true ;
19059     int arg4 = (int) 1 ;
19060     wxImageList *result;
19061     PyObject * obj0 = 0 ;
19062     PyObject * obj1 = 0 ;
19063     PyObject * obj2 = 0 ;
19064     PyObject * obj3 = 0 ;
19065     char *kwnames[] = {
19066         (char *) "width",(char *) "height",(char *) "mask",(char *) "initialCount", NULL
19067     };
19068
19069     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_ImageList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19070     {
19071         arg1 = (int)(SWIG_As_int(obj0));
19072         if (SWIG_arg_fail(1)) SWIG_fail;
19073     }
19074     {
19075         arg2 = (int)(SWIG_As_int(obj1));
19076         if (SWIG_arg_fail(2)) SWIG_fail;
19077     }
19078     if (obj2) {
19079         {
19080             arg3 = (int)(SWIG_As_int(obj2));
19081             if (SWIG_arg_fail(3)) SWIG_fail;
19082         }
19083     }
19084     if (obj3) {
19085         {
19086             arg4 = (int)(SWIG_As_int(obj3));
19087             if (SWIG_arg_fail(4)) SWIG_fail;
19088         }
19089     }
19090     {
19091         if (!wxPyCheckForApp()) SWIG_fail;
19092         PyThreadState* __tstate = wxPyBeginAllowThreads();
19093         result = (wxImageList *)new wxImageList(arg1,arg2,arg3,arg4);
19094
19095         wxPyEndAllowThreads(__tstate);
19096         if (PyErr_Occurred()) SWIG_fail;
19097     }
19098     {
19099         resultobj = wxPyMake_wxObject(result, 1);
19100     }
19101     return resultobj;
19102     fail:
19103     return NULL;
19104 }
19105
19106
19107 static PyObject *_wrap_delete_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
19108     PyObject *resultobj;
19109     wxImageList *arg1 = (wxImageList *) 0 ;
19110     PyObject * obj0 = 0 ;
19111     char *kwnames[] = {
19112         (char *) "self", NULL
19113     };
19114
19115     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ImageList",kwnames,&obj0)) goto fail;
19116     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19117     if (SWIG_arg_fail(1)) SWIG_fail;
19118     {
19119         PyThreadState* __tstate = wxPyBeginAllowThreads();
19120         delete arg1;
19121
19122         wxPyEndAllowThreads(__tstate);
19123         if (PyErr_Occurred()) SWIG_fail;
19124     }
19125     Py_INCREF(Py_None); resultobj = Py_None;
19126     return resultobj;
19127     fail:
19128     return NULL;
19129 }
19130
19131
19132 static PyObject *_wrap_ImageList_Add(PyObject *, PyObject *args, PyObject *kwargs) {
19133     PyObject *resultobj;
19134     wxImageList *arg1 = (wxImageList *) 0 ;
19135     wxBitmap *arg2 = 0 ;
19136     wxBitmap const &arg3_defvalue = wxNullBitmap ;
19137     wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
19138     int result;
19139     PyObject * obj0 = 0 ;
19140     PyObject * obj1 = 0 ;
19141     PyObject * obj2 = 0 ;
19142     char *kwnames[] = {
19143         (char *) "self",(char *) "bitmap",(char *) "mask", NULL
19144     };
19145
19146     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ImageList_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
19147     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19148     if (SWIG_arg_fail(1)) SWIG_fail;
19149     {
19150         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19151         if (SWIG_arg_fail(2)) SWIG_fail;
19152         if (arg2 == NULL) {
19153             SWIG_null_ref("wxBitmap");
19154         }
19155         if (SWIG_arg_fail(2)) SWIG_fail;
19156     }
19157     if (obj2) {
19158         {
19159             SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19160             if (SWIG_arg_fail(3)) SWIG_fail;
19161             if (arg3 == NULL) {
19162                 SWIG_null_ref("wxBitmap");
19163             }
19164             if (SWIG_arg_fail(3)) SWIG_fail;
19165         }
19166     }
19167     {
19168         PyThreadState* __tstate = wxPyBeginAllowThreads();
19169         result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
19170
19171         wxPyEndAllowThreads(__tstate);
19172         if (PyErr_Occurred()) SWIG_fail;
19173     }
19174     {
19175         resultobj = SWIG_From_int((int)(result));
19176     }
19177     return resultobj;
19178     fail:
19179     return NULL;
19180 }
19181
19182
19183 static PyObject *_wrap_ImageList_AddWithColourMask(PyObject *, PyObject *args, PyObject *kwargs) {
19184     PyObject *resultobj;
19185     wxImageList *arg1 = (wxImageList *) 0 ;
19186     wxBitmap *arg2 = 0 ;
19187     wxColour *arg3 = 0 ;
19188     int result;
19189     wxColour temp3 ;
19190     PyObject * obj0 = 0 ;
19191     PyObject * obj1 = 0 ;
19192     PyObject * obj2 = 0 ;
19193     char *kwnames[] = {
19194         (char *) "self",(char *) "bitmap",(char *) "maskColour", NULL
19195     };
19196
19197     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_AddWithColourMask",kwnames,&obj0,&obj1,&obj2)) goto fail;
19198     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19199     if (SWIG_arg_fail(1)) SWIG_fail;
19200     {
19201         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19202         if (SWIG_arg_fail(2)) SWIG_fail;
19203         if (arg2 == NULL) {
19204             SWIG_null_ref("wxBitmap");
19205         }
19206         if (SWIG_arg_fail(2)) SWIG_fail;
19207     }
19208     {
19209         arg3 = &temp3;
19210         if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
19211     }
19212     {
19213         PyThreadState* __tstate = wxPyBeginAllowThreads();
19214         result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxColour const &)*arg3);
19215
19216         wxPyEndAllowThreads(__tstate);
19217         if (PyErr_Occurred()) SWIG_fail;
19218     }
19219     {
19220         resultobj = SWIG_From_int((int)(result));
19221     }
19222     return resultobj;
19223     fail:
19224     return NULL;
19225 }
19226
19227
19228 static PyObject *_wrap_ImageList_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
19229     PyObject *resultobj;
19230     wxImageList *arg1 = (wxImageList *) 0 ;
19231     wxIcon *arg2 = 0 ;
19232     int result;
19233     PyObject * obj0 = 0 ;
19234     PyObject * obj1 = 0 ;
19235     char *kwnames[] = {
19236         (char *) "self",(char *) "icon", NULL
19237     };
19238
19239     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_AddIcon",kwnames,&obj0,&obj1)) goto fail;
19240     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19241     if (SWIG_arg_fail(1)) SWIG_fail;
19242     {
19243         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
19244         if (SWIG_arg_fail(2)) SWIG_fail;
19245         if (arg2 == NULL) {
19246             SWIG_null_ref("wxIcon");
19247         }
19248         if (SWIG_arg_fail(2)) SWIG_fail;
19249     }
19250     {
19251         PyThreadState* __tstate = wxPyBeginAllowThreads();
19252         result = (int)(arg1)->Add((wxIcon const &)*arg2);
19253
19254         wxPyEndAllowThreads(__tstate);
19255         if (PyErr_Occurred()) SWIG_fail;
19256     }
19257     {
19258         resultobj = SWIG_From_int((int)(result));
19259     }
19260     return resultobj;
19261     fail:
19262     return NULL;
19263 }
19264
19265
19266 static PyObject *_wrap_ImageList_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
19267     PyObject *resultobj;
19268     wxImageList *arg1 = (wxImageList *) 0 ;
19269     int arg2 ;
19270     SwigValueWrapper<wxBitmap > result;
19271     PyObject * obj0 = 0 ;
19272     PyObject * obj1 = 0 ;
19273     char *kwnames[] = {
19274         (char *) "self",(char *) "index", NULL
19275     };
19276
19277     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetBitmap",kwnames,&obj0,&obj1)) goto fail;
19278     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19279     if (SWIG_arg_fail(1)) SWIG_fail;
19280     {
19281         arg2 = (int)(SWIG_As_int(obj1));
19282         if (SWIG_arg_fail(2)) SWIG_fail;
19283     }
19284     {
19285         PyThreadState* __tstate = wxPyBeginAllowThreads();
19286         result = ((wxImageList const *)arg1)->GetBitmap(arg2);
19287
19288         wxPyEndAllowThreads(__tstate);
19289         if (PyErr_Occurred()) SWIG_fail;
19290     }
19291     {
19292         wxBitmap * resultptr;
19293         resultptr = new wxBitmap((wxBitmap &)(result));
19294         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
19295     }
19296     return resultobj;
19297     fail:
19298     return NULL;
19299 }
19300
19301
19302 static PyObject *_wrap_ImageList_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
19303     PyObject *resultobj;
19304     wxImageList *arg1 = (wxImageList *) 0 ;
19305     int arg2 ;
19306     wxIcon result;
19307     PyObject * obj0 = 0 ;
19308     PyObject * obj1 = 0 ;
19309     char *kwnames[] = {
19310         (char *) "self",(char *) "index", NULL
19311     };
19312
19313     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetIcon",kwnames,&obj0,&obj1)) goto fail;
19314     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19315     if (SWIG_arg_fail(1)) SWIG_fail;
19316     {
19317         arg2 = (int)(SWIG_As_int(obj1));
19318         if (SWIG_arg_fail(2)) SWIG_fail;
19319     }
19320     {
19321         PyThreadState* __tstate = wxPyBeginAllowThreads();
19322         result = ((wxImageList const *)arg1)->GetIcon(arg2);
19323
19324         wxPyEndAllowThreads(__tstate);
19325         if (PyErr_Occurred()) SWIG_fail;
19326     }
19327     {
19328         wxIcon * resultptr;
19329         resultptr = new wxIcon((wxIcon &)(result));
19330         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
19331     }
19332     return resultobj;
19333     fail:
19334     return NULL;
19335 }
19336
19337
19338 static PyObject *_wrap_ImageList_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
19339     PyObject *resultobj;
19340     wxImageList *arg1 = (wxImageList *) 0 ;
19341     int arg2 ;
19342     wxBitmap *arg3 = 0 ;
19343     wxBitmap const &arg4_defvalue = wxNullBitmap ;
19344     wxBitmap *arg4 = (wxBitmap *) &arg4_defvalue ;
19345     bool result;
19346     PyObject * obj0 = 0 ;
19347     PyObject * obj1 = 0 ;
19348     PyObject * obj2 = 0 ;
19349     PyObject * obj3 = 0 ;
19350     char *kwnames[] = {
19351         (char *) "self",(char *) "index",(char *) "bitmap",(char *) "mask", NULL
19352     };
19353
19354     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ImageList_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19355     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19356     if (SWIG_arg_fail(1)) SWIG_fail;
19357     {
19358         arg2 = (int)(SWIG_As_int(obj1));
19359         if (SWIG_arg_fail(2)) SWIG_fail;
19360     }
19361     {
19362         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19363         if (SWIG_arg_fail(3)) SWIG_fail;
19364         if (arg3 == NULL) {
19365             SWIG_null_ref("wxBitmap");
19366         }
19367         if (SWIG_arg_fail(3)) SWIG_fail;
19368     }
19369     if (obj3) {
19370         {
19371             SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19372             if (SWIG_arg_fail(4)) SWIG_fail;
19373             if (arg4 == NULL) {
19374                 SWIG_null_ref("wxBitmap");
19375             }
19376             if (SWIG_arg_fail(4)) SWIG_fail;
19377         }
19378     }
19379     {
19380         PyThreadState* __tstate = wxPyBeginAllowThreads();
19381         result = (bool)(arg1)->Replace(arg2,(wxBitmap const &)*arg3,(wxBitmap const &)*arg4);
19382
19383         wxPyEndAllowThreads(__tstate);
19384         if (PyErr_Occurred()) SWIG_fail;
19385     }
19386     {
19387         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19388     }
19389     return resultobj;
19390     fail:
19391     return NULL;
19392 }
19393
19394
19395 static PyObject *_wrap_ImageList_Draw(PyObject *, PyObject *args, PyObject *kwargs) {
19396     PyObject *resultobj;
19397     wxImageList *arg1 = (wxImageList *) 0 ;
19398     int arg2 ;
19399     wxDC *arg3 = 0 ;
19400     int arg4 ;
19401     int arg5 ;
19402     int arg6 = (int) wxIMAGELIST_DRAW_NORMAL ;
19403     bool arg7 = (bool) (bool)false ;
19404     bool result;
19405     PyObject * obj0 = 0 ;
19406     PyObject * obj1 = 0 ;
19407     PyObject * obj2 = 0 ;
19408     PyObject * obj3 = 0 ;
19409     PyObject * obj4 = 0 ;
19410     PyObject * obj5 = 0 ;
19411     PyObject * obj6 = 0 ;
19412     char *kwnames[] = {
19413         (char *) "self",(char *) "index",(char *) "dc",(char *) "x",(char *) "x",(char *) "flags",(char *) "solidBackground", NULL
19414     };
19415
19416     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OO:ImageList_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19417     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19418     if (SWIG_arg_fail(1)) SWIG_fail;
19419     {
19420         arg2 = (int)(SWIG_As_int(obj1));
19421         if (SWIG_arg_fail(2)) SWIG_fail;
19422     }
19423     {
19424         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19425         if (SWIG_arg_fail(3)) SWIG_fail;
19426         if (arg3 == NULL) {
19427             SWIG_null_ref("wxDC");
19428         }
19429         if (SWIG_arg_fail(3)) SWIG_fail;
19430     }
19431     {
19432         arg4 = (int)(SWIG_As_int(obj3));
19433         if (SWIG_arg_fail(4)) SWIG_fail;
19434     }
19435     {
19436         arg5 = (int)(SWIG_As_int(obj4));
19437         if (SWIG_arg_fail(5)) SWIG_fail;
19438     }
19439     if (obj5) {
19440         {
19441             arg6 = (int)(SWIG_As_int(obj5));
19442             if (SWIG_arg_fail(6)) SWIG_fail;
19443         }
19444     }
19445     if (obj6) {
19446         {
19447             arg7 = (bool const)(SWIG_As_bool(obj6));
19448             if (SWIG_arg_fail(7)) SWIG_fail;
19449         }
19450     }
19451     {
19452         PyThreadState* __tstate = wxPyBeginAllowThreads();
19453         result = (bool)(arg1)->Draw(arg2,*arg3,arg4,arg5,arg6,arg7);
19454
19455         wxPyEndAllowThreads(__tstate);
19456         if (PyErr_Occurred()) SWIG_fail;
19457     }
19458     {
19459         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19460     }
19461     return resultobj;
19462     fail:
19463     return NULL;
19464 }
19465
19466
19467 static PyObject *_wrap_ImageList_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
19468     PyObject *resultobj;
19469     wxImageList *arg1 = (wxImageList *) 0 ;
19470     int result;
19471     PyObject * obj0 = 0 ;
19472     char *kwnames[] = {
19473         (char *) "self", NULL
19474     };
19475
19476     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_GetImageCount",kwnames,&obj0)) goto fail;
19477     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19478     if (SWIG_arg_fail(1)) SWIG_fail;
19479     {
19480         PyThreadState* __tstate = wxPyBeginAllowThreads();
19481         result = (int)(arg1)->GetImageCount();
19482
19483         wxPyEndAllowThreads(__tstate);
19484         if (PyErr_Occurred()) SWIG_fail;
19485     }
19486     {
19487         resultobj = SWIG_From_int((int)(result));
19488     }
19489     return resultobj;
19490     fail:
19491     return NULL;
19492 }
19493
19494
19495 static PyObject *_wrap_ImageList_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
19496     PyObject *resultobj;
19497     wxImageList *arg1 = (wxImageList *) 0 ;
19498     int arg2 ;
19499     bool result;
19500     PyObject * obj0 = 0 ;
19501     PyObject * obj1 = 0 ;
19502     char *kwnames[] = {
19503         (char *) "self",(char *) "index", NULL
19504     };
19505
19506     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_Remove",kwnames,&obj0,&obj1)) goto fail;
19507     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19508     if (SWIG_arg_fail(1)) SWIG_fail;
19509     {
19510         arg2 = (int)(SWIG_As_int(obj1));
19511         if (SWIG_arg_fail(2)) SWIG_fail;
19512     }
19513     {
19514         PyThreadState* __tstate = wxPyBeginAllowThreads();
19515         result = (bool)(arg1)->Remove(arg2);
19516
19517         wxPyEndAllowThreads(__tstate);
19518         if (PyErr_Occurred()) SWIG_fail;
19519     }
19520     {
19521         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19522     }
19523     return resultobj;
19524     fail:
19525     return NULL;
19526 }
19527
19528
19529 static PyObject *_wrap_ImageList_RemoveAll(PyObject *, PyObject *args, PyObject *kwargs) {
19530     PyObject *resultobj;
19531     wxImageList *arg1 = (wxImageList *) 0 ;
19532     bool result;
19533     PyObject * obj0 = 0 ;
19534     char *kwnames[] = {
19535         (char *) "self", NULL
19536     };
19537
19538     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_RemoveAll",kwnames,&obj0)) goto fail;
19539     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19540     if (SWIG_arg_fail(1)) SWIG_fail;
19541     {
19542         PyThreadState* __tstate = wxPyBeginAllowThreads();
19543         result = (bool)(arg1)->RemoveAll();
19544
19545         wxPyEndAllowThreads(__tstate);
19546         if (PyErr_Occurred()) SWIG_fail;
19547     }
19548     {
19549         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19550     }
19551     return resultobj;
19552     fail:
19553     return NULL;
19554 }
19555
19556
19557 static PyObject *_wrap_ImageList_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19558     PyObject *resultobj;
19559     wxImageList *arg1 = (wxImageList *) 0 ;
19560     int arg2 ;
19561     int *arg3 = 0 ;
19562     int *arg4 = 0 ;
19563     int temp3 ;
19564     int res3 = 0 ;
19565     int temp4 ;
19566     int res4 = 0 ;
19567     PyObject * obj0 = 0 ;
19568     PyObject * obj1 = 0 ;
19569     char *kwnames[] = {
19570         (char *) "self",(char *) "index", NULL
19571     };
19572
19573     arg3 = &temp3; res3 = SWIG_NEWOBJ;
19574     arg4 = &temp4; res4 = SWIG_NEWOBJ;
19575     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetSize",kwnames,&obj0,&obj1)) goto fail;
19576     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19577     if (SWIG_arg_fail(1)) SWIG_fail;
19578     {
19579         arg2 = (int)(SWIG_As_int(obj1));
19580         if (SWIG_arg_fail(2)) SWIG_fail;
19581     }
19582     {
19583         PyThreadState* __tstate = wxPyBeginAllowThreads();
19584         (arg1)->GetSize(arg2,*arg3,*arg4);
19585
19586         wxPyEndAllowThreads(__tstate);
19587         if (PyErr_Occurred()) SWIG_fail;
19588     }
19589     Py_INCREF(Py_None); resultobj = Py_None;
19590     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19591     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
19592     resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
19593     SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
19594     return resultobj;
19595     fail:
19596     return NULL;
19597 }
19598
19599
19600 static PyObject * ImageList_swigregister(PyObject *, PyObject *args) {
19601     PyObject *obj;
19602     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19603     SWIG_TypeClientData(SWIGTYPE_p_wxImageList, obj);
19604     Py_INCREF(obj);
19605     return Py_BuildValue((char *)"");
19606 }
19607 static int _wrap_NORMAL_FONT_set(PyObject *) {
19608     PyErr_SetString(PyExc_TypeError,"Variable NORMAL_FONT is read-only.");
19609     return 1;
19610 }
19611
19612
19613 static PyObject *_wrap_NORMAL_FONT_get(void) {
19614     PyObject *pyobj;
19615
19616     pyobj = SWIG_NewPointerObj((void *)(wxNORMAL_FONT), SWIGTYPE_p_wxFont, 0);
19617     return pyobj;
19618 }
19619
19620
19621 static int _wrap_SMALL_FONT_set(PyObject *) {
19622     PyErr_SetString(PyExc_TypeError,"Variable SMALL_FONT is read-only.");
19623     return 1;
19624 }
19625
19626
19627 static PyObject *_wrap_SMALL_FONT_get(void) {
19628     PyObject *pyobj;
19629
19630     pyobj = SWIG_NewPointerObj((void *)(wxSMALL_FONT), SWIGTYPE_p_wxFont, 0);
19631     return pyobj;
19632 }
19633
19634
19635 static int _wrap_ITALIC_FONT_set(PyObject *) {
19636     PyErr_SetString(PyExc_TypeError,"Variable ITALIC_FONT is read-only.");
19637     return 1;
19638 }
19639
19640
19641 static PyObject *_wrap_ITALIC_FONT_get(void) {
19642     PyObject *pyobj;
19643
19644     pyobj = SWIG_NewPointerObj((void *)(wxITALIC_FONT), SWIGTYPE_p_wxFont, 0);
19645     return pyobj;
19646 }
19647
19648
19649 static int _wrap_SWISS_FONT_set(PyObject *) {
19650     PyErr_SetString(PyExc_TypeError,"Variable SWISS_FONT is read-only.");
19651     return 1;
19652 }
19653
19654
19655 static PyObject *_wrap_SWISS_FONT_get(void) {
19656     PyObject *pyobj;
19657
19658     pyobj = SWIG_NewPointerObj((void *)(wxSWISS_FONT), SWIGTYPE_p_wxFont, 0);
19659     return pyobj;
19660 }
19661
19662
19663 static int _wrap_RED_PEN_set(PyObject *) {
19664     PyErr_SetString(PyExc_TypeError,"Variable RED_PEN is read-only.");
19665     return 1;
19666 }
19667
19668
19669 static PyObject *_wrap_RED_PEN_get(void) {
19670     PyObject *pyobj;
19671
19672     pyobj = SWIG_NewPointerObj((void *)(wxRED_PEN), SWIGTYPE_p_wxPen, 0);
19673     return pyobj;
19674 }
19675
19676
19677 static int _wrap_CYAN_PEN_set(PyObject *) {
19678     PyErr_SetString(PyExc_TypeError,"Variable CYAN_PEN is read-only.");
19679     return 1;
19680 }
19681
19682
19683 static PyObject *_wrap_CYAN_PEN_get(void) {
19684     PyObject *pyobj;
19685
19686     pyobj = SWIG_NewPointerObj((void *)(wxCYAN_PEN), SWIGTYPE_p_wxPen, 0);
19687     return pyobj;
19688 }
19689
19690
19691 static int _wrap_GREEN_PEN_set(PyObject *) {
19692     PyErr_SetString(PyExc_TypeError,"Variable GREEN_PEN is read-only.");
19693     return 1;
19694 }
19695
19696
19697 static PyObject *_wrap_GREEN_PEN_get(void) {
19698     PyObject *pyobj;
19699
19700     pyobj = SWIG_NewPointerObj((void *)(wxGREEN_PEN), SWIGTYPE_p_wxPen, 0);
19701     return pyobj;
19702 }
19703
19704
19705 static int _wrap_BLACK_PEN_set(PyObject *) {
19706     PyErr_SetString(PyExc_TypeError,"Variable BLACK_PEN is read-only.");
19707     return 1;
19708 }
19709
19710
19711 static PyObject *_wrap_BLACK_PEN_get(void) {
19712     PyObject *pyobj;
19713
19714     pyobj = SWIG_NewPointerObj((void *)(wxBLACK_PEN), SWIGTYPE_p_wxPen, 0);
19715     return pyobj;
19716 }
19717
19718
19719 static int _wrap_WHITE_PEN_set(PyObject *) {
19720     PyErr_SetString(PyExc_TypeError,"Variable WHITE_PEN is read-only.");
19721     return 1;
19722 }
19723
19724
19725 static PyObject *_wrap_WHITE_PEN_get(void) {
19726     PyObject *pyobj;
19727
19728     pyobj = SWIG_NewPointerObj((void *)(wxWHITE_PEN), SWIGTYPE_p_wxPen, 0);
19729     return pyobj;
19730 }
19731
19732
19733 static int _wrap_TRANSPARENT_PEN_set(PyObject *) {
19734     PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_PEN is read-only.");
19735     return 1;
19736 }
19737
19738
19739 static PyObject *_wrap_TRANSPARENT_PEN_get(void) {
19740     PyObject *pyobj;
19741
19742     pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_PEN), SWIGTYPE_p_wxPen, 0);
19743     return pyobj;
19744 }
19745
19746
19747 static int _wrap_BLACK_DASHED_PEN_set(PyObject *) {
19748     PyErr_SetString(PyExc_TypeError,"Variable BLACK_DASHED_PEN is read-only.");
19749     return 1;
19750 }
19751
19752
19753 static PyObject *_wrap_BLACK_DASHED_PEN_get(void) {
19754     PyObject *pyobj;
19755
19756     pyobj = SWIG_NewPointerObj((void *)(wxBLACK_DASHED_PEN), SWIGTYPE_p_wxPen, 0);
19757     return pyobj;
19758 }
19759
19760
19761 static int _wrap_GREY_PEN_set(PyObject *) {
19762     PyErr_SetString(PyExc_TypeError,"Variable GREY_PEN is read-only.");
19763     return 1;
19764 }
19765
19766
19767 static PyObject *_wrap_GREY_PEN_get(void) {
19768     PyObject *pyobj;
19769
19770     pyobj = SWIG_NewPointerObj((void *)(wxGREY_PEN), SWIGTYPE_p_wxPen, 0);
19771     return pyobj;
19772 }
19773
19774
19775 static int _wrap_MEDIUM_GREY_PEN_set(PyObject *) {
19776     PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_PEN is read-only.");
19777     return 1;
19778 }
19779
19780
19781 static PyObject *_wrap_MEDIUM_GREY_PEN_get(void) {
19782     PyObject *pyobj;
19783
19784     pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_PEN), SWIGTYPE_p_wxPen, 0);
19785     return pyobj;
19786 }
19787
19788
19789 static int _wrap_LIGHT_GREY_PEN_set(PyObject *) {
19790     PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_PEN is read-only.");
19791     return 1;
19792 }
19793
19794
19795 static PyObject *_wrap_LIGHT_GREY_PEN_get(void) {
19796     PyObject *pyobj;
19797
19798     pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_PEN), SWIGTYPE_p_wxPen, 0);
19799     return pyobj;
19800 }
19801
19802
19803 static int _wrap_BLUE_BRUSH_set(PyObject *) {
19804     PyErr_SetString(PyExc_TypeError,"Variable BLUE_BRUSH is read-only.");
19805     return 1;
19806 }
19807
19808
19809 static PyObject *_wrap_BLUE_BRUSH_get(void) {
19810     PyObject *pyobj;
19811
19812     pyobj = SWIG_NewPointerObj((void *)(wxBLUE_BRUSH), SWIGTYPE_p_wxBrush, 0);
19813     return pyobj;
19814 }
19815
19816
19817 static int _wrap_GREEN_BRUSH_set(PyObject *) {
19818     PyErr_SetString(PyExc_TypeError,"Variable GREEN_BRUSH is read-only.");
19819     return 1;
19820 }
19821
19822
19823 static PyObject *_wrap_GREEN_BRUSH_get(void) {
19824     PyObject *pyobj;
19825
19826     pyobj = SWIG_NewPointerObj((void *)(wxGREEN_BRUSH), SWIGTYPE_p_wxBrush, 0);
19827     return pyobj;
19828 }
19829
19830
19831 static int _wrap_WHITE_BRUSH_set(PyObject *) {
19832     PyErr_SetString(PyExc_TypeError,"Variable WHITE_BRUSH is read-only.");
19833     return 1;
19834 }
19835
19836
19837 static PyObject *_wrap_WHITE_BRUSH_get(void) {
19838     PyObject *pyobj;
19839
19840     pyobj = SWIG_NewPointerObj((void *)(wxWHITE_BRUSH), SWIGTYPE_p_wxBrush, 0);
19841     return pyobj;
19842 }
19843
19844
19845 static int _wrap_BLACK_BRUSH_set(PyObject *) {
19846     PyErr_SetString(PyExc_TypeError,"Variable BLACK_BRUSH is read-only.");
19847     return 1;
19848 }
19849
19850
19851 static PyObject *_wrap_BLACK_BRUSH_get(void) {
19852     PyObject *pyobj;
19853
19854     pyobj = SWIG_NewPointerObj((void *)(wxBLACK_BRUSH), SWIGTYPE_p_wxBrush, 0);
19855     return pyobj;
19856 }
19857
19858
19859 static int _wrap_TRANSPARENT_BRUSH_set(PyObject *) {
19860     PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_BRUSH is read-only.");
19861     return 1;
19862 }
19863
19864
19865 static PyObject *_wrap_TRANSPARENT_BRUSH_get(void) {
19866     PyObject *pyobj;
19867
19868     pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_BRUSH), SWIGTYPE_p_wxBrush, 0);
19869     return pyobj;
19870 }
19871
19872
19873 static int _wrap_CYAN_BRUSH_set(PyObject *) {
19874     PyErr_SetString(PyExc_TypeError,"Variable CYAN_BRUSH is read-only.");
19875     return 1;
19876 }
19877
19878
19879 static PyObject *_wrap_CYAN_BRUSH_get(void) {
19880     PyObject *pyobj;
19881
19882     pyobj = SWIG_NewPointerObj((void *)(wxCYAN_BRUSH), SWIGTYPE_p_wxBrush, 0);
19883     return pyobj;
19884 }
19885
19886
19887 static int _wrap_RED_BRUSH_set(PyObject *) {
19888     PyErr_SetString(PyExc_TypeError,"Variable RED_BRUSH is read-only.");
19889     return 1;
19890 }
19891
19892
19893 static PyObject *_wrap_RED_BRUSH_get(void) {
19894     PyObject *pyobj;
19895
19896     pyobj = SWIG_NewPointerObj((void *)(wxRED_BRUSH), SWIGTYPE_p_wxBrush, 0);
19897     return pyobj;
19898 }
19899
19900
19901 static int _wrap_GREY_BRUSH_set(PyObject *) {
19902     PyErr_SetString(PyExc_TypeError,"Variable GREY_BRUSH is read-only.");
19903     return 1;
19904 }
19905
19906
19907 static PyObject *_wrap_GREY_BRUSH_get(void) {
19908     PyObject *pyobj;
19909
19910     pyobj = SWIG_NewPointerObj((void *)(wxGREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19911     return pyobj;
19912 }
19913
19914
19915 static int _wrap_MEDIUM_GREY_BRUSH_set(PyObject *) {
19916     PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_BRUSH is read-only.");
19917     return 1;
19918 }
19919
19920
19921 static PyObject *_wrap_MEDIUM_GREY_BRUSH_get(void) {
19922     PyObject *pyobj;
19923
19924     pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19925     return pyobj;
19926 }
19927
19928
19929 static int _wrap_LIGHT_GREY_BRUSH_set(PyObject *) {
19930     PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_BRUSH is read-only.");
19931     return 1;
19932 }
19933
19934
19935 static PyObject *_wrap_LIGHT_GREY_BRUSH_get(void) {
19936     PyObject *pyobj;
19937
19938     pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19939     return pyobj;
19940 }
19941
19942
19943 static int _wrap_BLACK_set(PyObject *) {
19944     PyErr_SetString(PyExc_TypeError,"Variable BLACK is read-only.");
19945     return 1;
19946 }
19947
19948
19949 static PyObject *_wrap_BLACK_get(void) {
19950     PyObject *pyobj;
19951
19952     pyobj = SWIG_NewPointerObj((void *)(wxBLACK), SWIGTYPE_p_wxColour, 0);
19953     return pyobj;
19954 }
19955
19956
19957 static int _wrap_WHITE_set(PyObject *) {
19958     PyErr_SetString(PyExc_TypeError,"Variable WHITE is read-only.");
19959     return 1;
19960 }
19961
19962
19963 static PyObject *_wrap_WHITE_get(void) {
19964     PyObject *pyobj;
19965
19966     pyobj = SWIG_NewPointerObj((void *)(wxWHITE), SWIGTYPE_p_wxColour, 0);
19967     return pyobj;
19968 }
19969
19970
19971 static int _wrap_RED_set(PyObject *) {
19972     PyErr_SetString(PyExc_TypeError,"Variable RED is read-only.");
19973     return 1;
19974 }
19975
19976
19977 static PyObject *_wrap_RED_get(void) {
19978     PyObject *pyobj;
19979
19980     pyobj = SWIG_NewPointerObj((void *)(wxRED), SWIGTYPE_p_wxColour, 0);
19981     return pyobj;
19982 }
19983
19984
19985 static int _wrap_BLUE_set(PyObject *) {
19986     PyErr_SetString(PyExc_TypeError,"Variable BLUE is read-only.");
19987     return 1;
19988 }
19989
19990
19991 static PyObject *_wrap_BLUE_get(void) {
19992     PyObject *pyobj;
19993
19994     pyobj = SWIG_NewPointerObj((void *)(wxBLUE), SWIGTYPE_p_wxColour, 0);
19995     return pyobj;
19996 }
19997
19998
19999 static int _wrap_GREEN_set(PyObject *) {
20000     PyErr_SetString(PyExc_TypeError,"Variable GREEN is read-only.");
20001     return 1;
20002 }
20003
20004
20005 static PyObject *_wrap_GREEN_get(void) {
20006     PyObject *pyobj;
20007
20008     pyobj = SWIG_NewPointerObj((void *)(wxGREEN), SWIGTYPE_p_wxColour, 0);
20009     return pyobj;
20010 }
20011
20012
20013 static int _wrap_CYAN_set(PyObject *) {
20014     PyErr_SetString(PyExc_TypeError,"Variable CYAN is read-only.");
20015     return 1;
20016 }
20017
20018
20019 static PyObject *_wrap_CYAN_get(void) {
20020     PyObject *pyobj;
20021
20022     pyobj = SWIG_NewPointerObj((void *)(wxCYAN), SWIGTYPE_p_wxColour, 0);
20023     return pyobj;
20024 }
20025
20026
20027 static int _wrap_LIGHT_GREY_set(PyObject *) {
20028     PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY is read-only.");
20029     return 1;
20030 }
20031
20032
20033 static PyObject *_wrap_LIGHT_GREY_get(void) {
20034     PyObject *pyobj;
20035
20036     pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY), SWIGTYPE_p_wxColour, 0);
20037     return pyobj;
20038 }
20039
20040
20041 static int _wrap_STANDARD_CURSOR_set(PyObject *) {
20042     PyErr_SetString(PyExc_TypeError,"Variable STANDARD_CURSOR is read-only.");
20043     return 1;
20044 }
20045
20046
20047 static PyObject *_wrap_STANDARD_CURSOR_get(void) {
20048     PyObject *pyobj;
20049
20050     pyobj = SWIG_NewPointerObj((void *)(wxSTANDARD_CURSOR), SWIGTYPE_p_wxCursor, 0);
20051     return pyobj;
20052 }
20053
20054
20055 static int _wrap_HOURGLASS_CURSOR_set(PyObject *) {
20056     PyErr_SetString(PyExc_TypeError,"Variable HOURGLASS_CURSOR is read-only.");
20057     return 1;
20058 }
20059
20060
20061 static PyObject *_wrap_HOURGLASS_CURSOR_get(void) {
20062     PyObject *pyobj;
20063
20064     pyobj = SWIG_NewPointerObj((void *)(wxHOURGLASS_CURSOR), SWIGTYPE_p_wxCursor, 0);
20065     return pyobj;
20066 }
20067
20068
20069 static int _wrap_CROSS_CURSOR_set(PyObject *) {
20070     PyErr_SetString(PyExc_TypeError,"Variable CROSS_CURSOR is read-only.");
20071     return 1;
20072 }
20073
20074
20075 static PyObject *_wrap_CROSS_CURSOR_get(void) {
20076     PyObject *pyobj;
20077
20078     pyobj = SWIG_NewPointerObj((void *)(wxCROSS_CURSOR), SWIGTYPE_p_wxCursor, 0);
20079     return pyobj;
20080 }
20081
20082
20083 static int _wrap_NullBitmap_set(PyObject *) {
20084     PyErr_SetString(PyExc_TypeError,"Variable NullBitmap is read-only.");
20085     return 1;
20086 }
20087
20088
20089 static PyObject *_wrap_NullBitmap_get(void) {
20090     PyObject *pyobj;
20091
20092     pyobj = SWIG_NewPointerObj((void *)(&wxNullBitmap), SWIGTYPE_p_wxBitmap, 0);
20093     return pyobj;
20094 }
20095
20096
20097 static int _wrap_NullIcon_set(PyObject *) {
20098     PyErr_SetString(PyExc_TypeError,"Variable NullIcon is read-only.");
20099     return 1;
20100 }
20101
20102
20103 static PyObject *_wrap_NullIcon_get(void) {
20104     PyObject *pyobj;
20105
20106     pyobj = SWIG_NewPointerObj((void *)(&wxNullIcon), SWIGTYPE_p_wxIcon, 0);
20107     return pyobj;
20108 }
20109
20110
20111 static int _wrap_NullCursor_set(PyObject *) {
20112     PyErr_SetString(PyExc_TypeError,"Variable NullCursor is read-only.");
20113     return 1;
20114 }
20115
20116
20117 static PyObject *_wrap_NullCursor_get(void) {
20118     PyObject *pyobj;
20119
20120     pyobj = SWIG_NewPointerObj((void *)(&wxNullCursor), SWIGTYPE_p_wxCursor, 0);
20121     return pyobj;
20122 }
20123
20124
20125 static int _wrap_NullPen_set(PyObject *) {
20126     PyErr_SetString(PyExc_TypeError,"Variable NullPen is read-only.");
20127     return 1;
20128 }
20129
20130
20131 static PyObject *_wrap_NullPen_get(void) {
20132     PyObject *pyobj;
20133
20134     pyobj = SWIG_NewPointerObj((void *)(&wxNullPen), SWIGTYPE_p_wxPen, 0);
20135     return pyobj;
20136 }
20137
20138
20139 static int _wrap_NullBrush_set(PyObject *) {
20140     PyErr_SetString(PyExc_TypeError,"Variable NullBrush is read-only.");
20141     return 1;
20142 }
20143
20144
20145 static PyObject *_wrap_NullBrush_get(void) {
20146     PyObject *pyobj;
20147
20148     pyobj = SWIG_NewPointerObj((void *)(&wxNullBrush), SWIGTYPE_p_wxBrush, 0);
20149     return pyobj;
20150 }
20151
20152
20153 static int _wrap_NullPalette_set(PyObject *) {
20154     PyErr_SetString(PyExc_TypeError,"Variable NullPalette is read-only.");
20155     return 1;
20156 }
20157
20158
20159 static PyObject *_wrap_NullPalette_get(void) {
20160     PyObject *pyobj;
20161
20162     pyobj = SWIG_NewPointerObj((void *)(&wxNullPalette), SWIGTYPE_p_wxPalette, 0);
20163     return pyobj;
20164 }
20165
20166
20167 static int _wrap_NullFont_set(PyObject *) {
20168     PyErr_SetString(PyExc_TypeError,"Variable NullFont is read-only.");
20169     return 1;
20170 }
20171
20172
20173 static PyObject *_wrap_NullFont_get(void) {
20174     PyObject *pyobj;
20175
20176     pyobj = SWIG_NewPointerObj((void *)(&wxNullFont), SWIGTYPE_p_wxFont, 0);
20177     return pyobj;
20178 }
20179
20180
20181 static int _wrap_NullColour_set(PyObject *) {
20182     PyErr_SetString(PyExc_TypeError,"Variable NullColour is read-only.");
20183     return 1;
20184 }
20185
20186
20187 static PyObject *_wrap_NullColour_get(void) {
20188     PyObject *pyobj;
20189
20190     pyobj = SWIG_NewPointerObj((void *)(&wxNullColour), SWIGTYPE_p_wxColour, 0);
20191     return pyobj;
20192 }
20193
20194
20195 static PyObject *_wrap_PenList_AddPen(PyObject *, PyObject *args, PyObject *kwargs) {
20196     PyObject *resultobj;
20197     wxPenList *arg1 = (wxPenList *) 0 ;
20198     wxPen *arg2 = (wxPen *) 0 ;
20199     PyObject * obj0 = 0 ;
20200     PyObject * obj1 = 0 ;
20201     char *kwnames[] = {
20202         (char *) "self",(char *) "pen", NULL
20203     };
20204
20205     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_AddPen",kwnames,&obj0,&obj1)) goto fail;
20206     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
20207     if (SWIG_arg_fail(1)) SWIG_fail;
20208     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
20209     if (SWIG_arg_fail(2)) SWIG_fail;
20210     {
20211         PyThreadState* __tstate = wxPyBeginAllowThreads();
20212         (arg1)->AddPen(arg2);
20213
20214         wxPyEndAllowThreads(__tstate);
20215         if (PyErr_Occurred()) SWIG_fail;
20216     }
20217     Py_INCREF(Py_None); resultobj = Py_None;
20218     return resultobj;
20219     fail:
20220     return NULL;
20221 }
20222
20223
20224 static PyObject *_wrap_PenList_FindOrCreatePen(PyObject *, PyObject *args, PyObject *kwargs) {
20225     PyObject *resultobj;
20226     wxPenList *arg1 = (wxPenList *) 0 ;
20227     wxColour *arg2 = 0 ;
20228     int arg3 ;
20229     int arg4 ;
20230     wxPen *result;
20231     wxColour temp2 ;
20232     PyObject * obj0 = 0 ;
20233     PyObject * obj1 = 0 ;
20234     PyObject * obj2 = 0 ;
20235     PyObject * obj3 = 0 ;
20236     char *kwnames[] = {
20237         (char *) "self",(char *) "colour",(char *) "width",(char *) "style", NULL
20238     };
20239
20240     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PenList_FindOrCreatePen",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20241     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
20242     if (SWIG_arg_fail(1)) SWIG_fail;
20243     {
20244         arg2 = &temp2;
20245         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20246     }
20247     {
20248         arg3 = (int)(SWIG_As_int(obj2));
20249         if (SWIG_arg_fail(3)) SWIG_fail;
20250     }
20251     {
20252         arg4 = (int)(SWIG_As_int(obj3));
20253         if (SWIG_arg_fail(4)) SWIG_fail;
20254     }
20255     {
20256         PyThreadState* __tstate = wxPyBeginAllowThreads();
20257         result = (wxPen *)(arg1)->FindOrCreatePen((wxColour const &)*arg2,arg3,arg4);
20258
20259         wxPyEndAllowThreads(__tstate);
20260         if (PyErr_Occurred()) SWIG_fail;
20261     }
20262     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 0);
20263     return resultobj;
20264     fail:
20265     return NULL;
20266 }
20267
20268
20269 static PyObject *_wrap_PenList_RemovePen(PyObject *, PyObject *args, PyObject *kwargs) {
20270     PyObject *resultobj;
20271     wxPenList *arg1 = (wxPenList *) 0 ;
20272     wxPen *arg2 = (wxPen *) 0 ;
20273     PyObject * obj0 = 0 ;
20274     PyObject * obj1 = 0 ;
20275     char *kwnames[] = {
20276         (char *) "self",(char *) "pen", NULL
20277     };
20278
20279     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_RemovePen",kwnames,&obj0,&obj1)) goto fail;
20280     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
20281     if (SWIG_arg_fail(1)) SWIG_fail;
20282     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
20283     if (SWIG_arg_fail(2)) SWIG_fail;
20284     {
20285         PyThreadState* __tstate = wxPyBeginAllowThreads();
20286         (arg1)->RemovePen(arg2);
20287
20288         wxPyEndAllowThreads(__tstate);
20289         if (PyErr_Occurred()) SWIG_fail;
20290     }
20291     Py_INCREF(Py_None); resultobj = Py_None;
20292     return resultobj;
20293     fail:
20294     return NULL;
20295 }
20296
20297
20298 static PyObject *_wrap_PenList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
20299     PyObject *resultobj;
20300     wxPenList *arg1 = (wxPenList *) 0 ;
20301     int result;
20302     PyObject * obj0 = 0 ;
20303     char *kwnames[] = {
20304         (char *) "self", NULL
20305     };
20306
20307     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PenList_GetCount",kwnames,&obj0)) goto fail;
20308     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
20309     if (SWIG_arg_fail(1)) SWIG_fail;
20310     {
20311         PyThreadState* __tstate = wxPyBeginAllowThreads();
20312         result = (int)(arg1)->GetCount();
20313
20314         wxPyEndAllowThreads(__tstate);
20315         if (PyErr_Occurred()) SWIG_fail;
20316     }
20317     {
20318         resultobj = SWIG_From_int((int)(result));
20319     }
20320     return resultobj;
20321     fail:
20322     return NULL;
20323 }
20324
20325
20326 static PyObject * PenList_swigregister(PyObject *, PyObject *args) {
20327     PyObject *obj;
20328     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20329     SWIG_TypeClientData(SWIGTYPE_p_wxPenList, obj);
20330     Py_INCREF(obj);
20331     return Py_BuildValue((char *)"");
20332 }
20333 static PyObject *_wrap_BrushList_AddBrush(PyObject *, PyObject *args, PyObject *kwargs) {
20334     PyObject *resultobj;
20335     wxBrushList *arg1 = (wxBrushList *) 0 ;
20336     wxBrush *arg2 = (wxBrush *) 0 ;
20337     PyObject * obj0 = 0 ;
20338     PyObject * obj1 = 0 ;
20339     char *kwnames[] = {
20340         (char *) "self",(char *) "brush", NULL
20341     };
20342
20343     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_AddBrush",kwnames,&obj0,&obj1)) 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     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
20347     if (SWIG_arg_fail(2)) SWIG_fail;
20348     {
20349         PyThreadState* __tstate = wxPyBeginAllowThreads();
20350         (arg1)->AddBrush(arg2);
20351
20352         wxPyEndAllowThreads(__tstate);
20353         if (PyErr_Occurred()) SWIG_fail;
20354     }
20355     Py_INCREF(Py_None); resultobj = Py_None;
20356     return resultobj;
20357     fail:
20358     return NULL;
20359 }
20360
20361
20362 static PyObject *_wrap_BrushList_FindOrCreateBrush(PyObject *, PyObject *args, PyObject *kwargs) {
20363     PyObject *resultobj;
20364     wxBrushList *arg1 = (wxBrushList *) 0 ;
20365     wxColour *arg2 = 0 ;
20366     int arg3 = (int) wxSOLID ;
20367     wxBrush *result;
20368     wxColour temp2 ;
20369     PyObject * obj0 = 0 ;
20370     PyObject * obj1 = 0 ;
20371     PyObject * obj2 = 0 ;
20372     char *kwnames[] = {
20373         (char *) "self",(char *) "colour",(char *) "style", NULL
20374     };
20375
20376     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:BrushList_FindOrCreateBrush",kwnames,&obj0,&obj1,&obj2)) goto fail;
20377     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
20378     if (SWIG_arg_fail(1)) SWIG_fail;
20379     {
20380         arg2 = &temp2;
20381         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20382     }
20383     if (obj2) {
20384         {
20385             arg3 = (int)(SWIG_As_int(obj2));
20386             if (SWIG_arg_fail(3)) SWIG_fail;
20387         }
20388     }
20389     {
20390         PyThreadState* __tstate = wxPyBeginAllowThreads();
20391         result = (wxBrush *)(arg1)->FindOrCreateBrush((wxColour const &)*arg2,arg3);
20392
20393         wxPyEndAllowThreads(__tstate);
20394         if (PyErr_Occurred()) SWIG_fail;
20395     }
20396     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 0);
20397     return resultobj;
20398     fail:
20399     return NULL;
20400 }
20401
20402
20403 static PyObject *_wrap_BrushList_RemoveBrush(PyObject *, PyObject *args, PyObject *kwargs) {
20404     PyObject *resultobj;
20405     wxBrushList *arg1 = (wxBrushList *) 0 ;
20406     wxBrush *arg2 = (wxBrush *) 0 ;
20407     PyObject * obj0 = 0 ;
20408     PyObject * obj1 = 0 ;
20409     char *kwnames[] = {
20410         (char *) "self",(char *) "brush", NULL
20411     };
20412
20413     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_RemoveBrush",kwnames,&obj0,&obj1)) goto fail;
20414     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
20415     if (SWIG_arg_fail(1)) SWIG_fail;
20416     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
20417     if (SWIG_arg_fail(2)) SWIG_fail;
20418     {
20419         PyThreadState* __tstate = wxPyBeginAllowThreads();
20420         (arg1)->RemoveBrush(arg2);
20421
20422         wxPyEndAllowThreads(__tstate);
20423         if (PyErr_Occurred()) SWIG_fail;
20424     }
20425     Py_INCREF(Py_None); resultobj = Py_None;
20426     return resultobj;
20427     fail:
20428     return NULL;
20429 }
20430
20431
20432 static PyObject *_wrap_BrushList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
20433     PyObject *resultobj;
20434     wxBrushList *arg1 = (wxBrushList *) 0 ;
20435     int result;
20436     PyObject * obj0 = 0 ;
20437     char *kwnames[] = {
20438         (char *) "self", NULL
20439     };
20440
20441     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BrushList_GetCount",kwnames,&obj0)) goto fail;
20442     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
20443     if (SWIG_arg_fail(1)) SWIG_fail;
20444     {
20445         PyThreadState* __tstate = wxPyBeginAllowThreads();
20446         result = (int)(arg1)->GetCount();
20447
20448         wxPyEndAllowThreads(__tstate);
20449         if (PyErr_Occurred()) SWIG_fail;
20450     }
20451     {
20452         resultobj = SWIG_From_int((int)(result));
20453     }
20454     return resultobj;
20455     fail:
20456     return NULL;
20457 }
20458
20459
20460 static PyObject * BrushList_swigregister(PyObject *, PyObject *args) {
20461     PyObject *obj;
20462     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20463     SWIG_TypeClientData(SWIGTYPE_p_wxBrushList, obj);
20464     Py_INCREF(obj);
20465     return Py_BuildValue((char *)"");
20466 }
20467 static PyObject *_wrap_new_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
20468     PyObject *resultobj;
20469     wxColourDatabase *result;
20470     char *kwnames[] = {
20471         NULL
20472     };
20473
20474     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ColourDatabase",kwnames)) goto fail;
20475     {
20476         if (!wxPyCheckForApp()) SWIG_fail;
20477         PyThreadState* __tstate = wxPyBeginAllowThreads();
20478         result = (wxColourDatabase *)new wxColourDatabase();
20479
20480         wxPyEndAllowThreads(__tstate);
20481         if (PyErr_Occurred()) SWIG_fail;
20482     }
20483     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourDatabase, 1);
20484     return resultobj;
20485     fail:
20486     return NULL;
20487 }
20488
20489
20490 static PyObject *_wrap_delete_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
20491     PyObject *resultobj;
20492     wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20493     PyObject * obj0 = 0 ;
20494     char *kwnames[] = {
20495         (char *) "self", NULL
20496     };
20497
20498     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ColourDatabase",kwnames,&obj0)) goto fail;
20499     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20500     if (SWIG_arg_fail(1)) SWIG_fail;
20501     {
20502         PyThreadState* __tstate = wxPyBeginAllowThreads();
20503         delete arg1;
20504
20505         wxPyEndAllowThreads(__tstate);
20506         if (PyErr_Occurred()) SWIG_fail;
20507     }
20508     Py_INCREF(Py_None); resultobj = Py_None;
20509     return resultobj;
20510     fail:
20511     return NULL;
20512 }
20513
20514
20515 static PyObject *_wrap_ColourDatabase_Find(PyObject *, PyObject *args, PyObject *kwargs) {
20516     PyObject *resultobj;
20517     wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20518     wxString *arg2 = 0 ;
20519     wxColour result;
20520     bool temp2 = false ;
20521     PyObject * obj0 = 0 ;
20522     PyObject * obj1 = 0 ;
20523     char *kwnames[] = {
20524         (char *) "self",(char *) "name", NULL
20525     };
20526
20527     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_Find",kwnames,&obj0,&obj1)) goto fail;
20528     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20529     if (SWIG_arg_fail(1)) SWIG_fail;
20530     {
20531         arg2 = wxString_in_helper(obj1);
20532         if (arg2 == NULL) SWIG_fail;
20533         temp2 = true;
20534     }
20535     {
20536         PyThreadState* __tstate = wxPyBeginAllowThreads();
20537         result = ((wxColourDatabase const *)arg1)->Find((wxString const &)*arg2);
20538
20539         wxPyEndAllowThreads(__tstate);
20540         if (PyErr_Occurred()) SWIG_fail;
20541     }
20542     {
20543         wxColour * resultptr;
20544         resultptr = new wxColour((wxColour &)(result));
20545         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20546     }
20547     {
20548         if (temp2)
20549         delete arg2;
20550     }
20551     return resultobj;
20552     fail:
20553     {
20554         if (temp2)
20555         delete arg2;
20556     }
20557     return NULL;
20558 }
20559
20560
20561 static PyObject *_wrap_ColourDatabase_FindName(PyObject *, PyObject *args, PyObject *kwargs) {
20562     PyObject *resultobj;
20563     wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20564     wxColour *arg2 = 0 ;
20565     wxString result;
20566     wxColour temp2 ;
20567     PyObject * obj0 = 0 ;
20568     PyObject * obj1 = 0 ;
20569     char *kwnames[] = {
20570         (char *) "self",(char *) "colour", NULL
20571     };
20572
20573     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_FindName",kwnames,&obj0,&obj1)) goto fail;
20574     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20575     if (SWIG_arg_fail(1)) SWIG_fail;
20576     {
20577         arg2 = &temp2;
20578         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20579     }
20580     {
20581         PyThreadState* __tstate = wxPyBeginAllowThreads();
20582         result = ((wxColourDatabase const *)arg1)->FindName((wxColour const &)*arg2);
20583
20584         wxPyEndAllowThreads(__tstate);
20585         if (PyErr_Occurred()) SWIG_fail;
20586     }
20587     {
20588 #if wxUSE_UNICODE
20589         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20590 #else
20591         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20592 #endif
20593     }
20594     return resultobj;
20595     fail:
20596     return NULL;
20597 }
20598
20599
20600 static PyObject *_wrap_ColourDatabase_AddColour(PyObject *, PyObject *args, PyObject *kwargs) {
20601     PyObject *resultobj;
20602     wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20603     wxString *arg2 = 0 ;
20604     wxColour *arg3 = 0 ;
20605     bool temp2 = false ;
20606     wxColour temp3 ;
20607     PyObject * obj0 = 0 ;
20608     PyObject * obj1 = 0 ;
20609     PyObject * obj2 = 0 ;
20610     char *kwnames[] = {
20611         (char *) "self",(char *) "name",(char *) "colour", NULL
20612     };
20613
20614     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ColourDatabase_AddColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
20615     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20616     if (SWIG_arg_fail(1)) SWIG_fail;
20617     {
20618         arg2 = wxString_in_helper(obj1);
20619         if (arg2 == NULL) SWIG_fail;
20620         temp2 = true;
20621     }
20622     {
20623         arg3 = &temp3;
20624         if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
20625     }
20626     {
20627         PyThreadState* __tstate = wxPyBeginAllowThreads();
20628         (arg1)->AddColour((wxString const &)*arg2,(wxColour const &)*arg3);
20629
20630         wxPyEndAllowThreads(__tstate);
20631         if (PyErr_Occurred()) SWIG_fail;
20632     }
20633     Py_INCREF(Py_None); resultobj = Py_None;
20634     {
20635         if (temp2)
20636         delete arg2;
20637     }
20638     return resultobj;
20639     fail:
20640     {
20641         if (temp2)
20642         delete arg2;
20643     }
20644     return NULL;
20645 }
20646
20647
20648 static PyObject *_wrap_ColourDatabase_Append(PyObject *, PyObject *args, PyObject *kwargs) {
20649     PyObject *resultobj;
20650     wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20651     wxString *arg2 = 0 ;
20652     int arg3 ;
20653     int arg4 ;
20654     int arg5 ;
20655     bool temp2 = false ;
20656     PyObject * obj0 = 0 ;
20657     PyObject * obj1 = 0 ;
20658     PyObject * obj2 = 0 ;
20659     PyObject * obj3 = 0 ;
20660     PyObject * obj4 = 0 ;
20661     char *kwnames[] = {
20662         (char *) "self",(char *) "name",(char *) "red",(char *) "green",(char *) "blue", NULL
20663     };
20664
20665     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:ColourDatabase_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20666     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20667     if (SWIG_arg_fail(1)) SWIG_fail;
20668     {
20669         arg2 = wxString_in_helper(obj1);
20670         if (arg2 == NULL) SWIG_fail;
20671         temp2 = true;
20672     }
20673     {
20674         arg3 = (int)(SWIG_As_int(obj2));
20675         if (SWIG_arg_fail(3)) SWIG_fail;
20676     }
20677     {
20678         arg4 = (int)(SWIG_As_int(obj3));
20679         if (SWIG_arg_fail(4)) SWIG_fail;
20680     }
20681     {
20682         arg5 = (int)(SWIG_As_int(obj4));
20683         if (SWIG_arg_fail(5)) SWIG_fail;
20684     }
20685     {
20686         PyThreadState* __tstate = wxPyBeginAllowThreads();
20687         wxColourDatabase_Append(arg1,(wxString const &)*arg2,arg3,arg4,arg5);
20688
20689         wxPyEndAllowThreads(__tstate);
20690         if (PyErr_Occurred()) SWIG_fail;
20691     }
20692     Py_INCREF(Py_None); resultobj = Py_None;
20693     {
20694         if (temp2)
20695         delete arg2;
20696     }
20697     return resultobj;
20698     fail:
20699     {
20700         if (temp2)
20701         delete arg2;
20702     }
20703     return NULL;
20704 }
20705
20706
20707 static PyObject * ColourDatabase_swigregister(PyObject *, PyObject *args) {
20708     PyObject *obj;
20709     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20710     SWIG_TypeClientData(SWIGTYPE_p_wxColourDatabase, obj);
20711     Py_INCREF(obj);
20712     return Py_BuildValue((char *)"");
20713 }
20714 static PyObject *_wrap_FontList_AddFont(PyObject *, PyObject *args, PyObject *kwargs) {
20715     PyObject *resultobj;
20716     wxFontList *arg1 = (wxFontList *) 0 ;
20717     wxFont *arg2 = (wxFont *) 0 ;
20718     PyObject * obj0 = 0 ;
20719     PyObject * obj1 = 0 ;
20720     char *kwnames[] = {
20721         (char *) "self",(char *) "font", NULL
20722     };
20723
20724     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_AddFont",kwnames,&obj0,&obj1)) goto fail;
20725     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20726     if (SWIG_arg_fail(1)) SWIG_fail;
20727     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
20728     if (SWIG_arg_fail(2)) SWIG_fail;
20729     {
20730         PyThreadState* __tstate = wxPyBeginAllowThreads();
20731         (arg1)->AddFont(arg2);
20732
20733         wxPyEndAllowThreads(__tstate);
20734         if (PyErr_Occurred()) SWIG_fail;
20735     }
20736     Py_INCREF(Py_None); resultobj = Py_None;
20737     return resultobj;
20738     fail:
20739     return NULL;
20740 }
20741
20742
20743 static PyObject *_wrap_FontList_FindOrCreateFont(PyObject *, PyObject *args, PyObject *kwargs) {
20744     PyObject *resultobj;
20745     wxFontList *arg1 = (wxFontList *) 0 ;
20746     int arg2 ;
20747     int arg3 ;
20748     int arg4 ;
20749     int arg5 ;
20750     bool arg6 = (bool) false ;
20751     wxString const &arg7_defvalue = wxPyEmptyString ;
20752     wxString *arg7 = (wxString *) &arg7_defvalue ;
20753     wxFontEncoding arg8 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
20754     wxFont *result;
20755     bool temp7 = false ;
20756     PyObject * obj0 = 0 ;
20757     PyObject * obj1 = 0 ;
20758     PyObject * obj2 = 0 ;
20759     PyObject * obj3 = 0 ;
20760     PyObject * obj4 = 0 ;
20761     PyObject * obj5 = 0 ;
20762     PyObject * obj6 = 0 ;
20763     PyObject * obj7 = 0 ;
20764     char *kwnames[] = {
20765         (char *) "self",(char *) "point_size",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "facename",(char *) "encoding", NULL
20766     };
20767
20768     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:FontList_FindOrCreateFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20769     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20770     if (SWIG_arg_fail(1)) SWIG_fail;
20771     {
20772         arg2 = (int)(SWIG_As_int(obj1));
20773         if (SWIG_arg_fail(2)) SWIG_fail;
20774     }
20775     {
20776         arg3 = (int)(SWIG_As_int(obj2));
20777         if (SWIG_arg_fail(3)) SWIG_fail;
20778     }
20779     {
20780         arg4 = (int)(SWIG_As_int(obj3));
20781         if (SWIG_arg_fail(4)) SWIG_fail;
20782     }
20783     {
20784         arg5 = (int)(SWIG_As_int(obj4));
20785         if (SWIG_arg_fail(5)) SWIG_fail;
20786     }
20787     if (obj5) {
20788         {
20789             arg6 = (bool)(SWIG_As_bool(obj5));
20790             if (SWIG_arg_fail(6)) SWIG_fail;
20791         }
20792     }
20793     if (obj6) {
20794         {
20795             arg7 = wxString_in_helper(obj6);
20796             if (arg7 == NULL) SWIG_fail;
20797             temp7 = true;
20798         }
20799     }
20800     if (obj7) {
20801         {
20802             arg8 = (wxFontEncoding)(SWIG_As_int(obj7));
20803             if (SWIG_arg_fail(8)) SWIG_fail;
20804         }
20805     }
20806     {
20807         PyThreadState* __tstate = wxPyBeginAllowThreads();
20808         result = (wxFont *)(arg1)->FindOrCreateFont(arg2,arg3,arg4,arg5,arg6,(wxString const &)*arg7,(wxFontEncoding )arg8);
20809
20810         wxPyEndAllowThreads(__tstate);
20811         if (PyErr_Occurred()) SWIG_fail;
20812     }
20813     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
20814     {
20815         if (temp7)
20816         delete arg7;
20817     }
20818     return resultobj;
20819     fail:
20820     {
20821         if (temp7)
20822         delete arg7;
20823     }
20824     return NULL;
20825 }
20826
20827
20828 static PyObject *_wrap_FontList_RemoveFont(PyObject *, PyObject *args, PyObject *kwargs) {
20829     PyObject *resultobj;
20830     wxFontList *arg1 = (wxFontList *) 0 ;
20831     wxFont *arg2 = (wxFont *) 0 ;
20832     PyObject * obj0 = 0 ;
20833     PyObject * obj1 = 0 ;
20834     char *kwnames[] = {
20835         (char *) "self",(char *) "font", NULL
20836     };
20837
20838     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_RemoveFont",kwnames,&obj0,&obj1)) goto fail;
20839     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20840     if (SWIG_arg_fail(1)) SWIG_fail;
20841     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
20842     if (SWIG_arg_fail(2)) SWIG_fail;
20843     {
20844         PyThreadState* __tstate = wxPyBeginAllowThreads();
20845         (arg1)->RemoveFont(arg2);
20846
20847         wxPyEndAllowThreads(__tstate);
20848         if (PyErr_Occurred()) SWIG_fail;
20849     }
20850     Py_INCREF(Py_None); resultobj = Py_None;
20851     return resultobj;
20852     fail:
20853     return NULL;
20854 }
20855
20856
20857 static PyObject *_wrap_FontList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
20858     PyObject *resultobj;
20859     wxFontList *arg1 = (wxFontList *) 0 ;
20860     int result;
20861     PyObject * obj0 = 0 ;
20862     char *kwnames[] = {
20863         (char *) "self", NULL
20864     };
20865
20866     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontList_GetCount",kwnames,&obj0)) goto fail;
20867     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20868     if (SWIG_arg_fail(1)) SWIG_fail;
20869     {
20870         PyThreadState* __tstate = wxPyBeginAllowThreads();
20871         result = (int)(arg1)->GetCount();
20872
20873         wxPyEndAllowThreads(__tstate);
20874         if (PyErr_Occurred()) SWIG_fail;
20875     }
20876     {
20877         resultobj = SWIG_From_int((int)(result));
20878     }
20879     return resultobj;
20880     fail:
20881     return NULL;
20882 }
20883
20884
20885 static PyObject * FontList_swigregister(PyObject *, PyObject *args) {
20886     PyObject *obj;
20887     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20888     SWIG_TypeClientData(SWIGTYPE_p_wxFontList, obj);
20889     Py_INCREF(obj);
20890     return Py_BuildValue((char *)"");
20891 }
20892 static int _wrap_TheFontList_set(PyObject *) {
20893     PyErr_SetString(PyExc_TypeError,"Variable TheFontList is read-only.");
20894     return 1;
20895 }
20896
20897
20898 static PyObject *_wrap_TheFontList_get(void) {
20899     PyObject *pyobj;
20900
20901     pyobj = SWIG_NewPointerObj((void *)(wxTheFontList), SWIGTYPE_p_wxFontList, 0);
20902     return pyobj;
20903 }
20904
20905
20906 static int _wrap_ThePenList_set(PyObject *) {
20907     PyErr_SetString(PyExc_TypeError,"Variable ThePenList is read-only.");
20908     return 1;
20909 }
20910
20911
20912 static PyObject *_wrap_ThePenList_get(void) {
20913     PyObject *pyobj;
20914
20915     pyobj = SWIG_NewPointerObj((void *)(wxThePenList), SWIGTYPE_p_wxPenList, 0);
20916     return pyobj;
20917 }
20918
20919
20920 static int _wrap_TheBrushList_set(PyObject *) {
20921     PyErr_SetString(PyExc_TypeError,"Variable TheBrushList is read-only.");
20922     return 1;
20923 }
20924
20925
20926 static PyObject *_wrap_TheBrushList_get(void) {
20927     PyObject *pyobj;
20928
20929     pyobj = SWIG_NewPointerObj((void *)(wxTheBrushList), SWIGTYPE_p_wxBrushList, 0);
20930     return pyobj;
20931 }
20932
20933
20934 static int _wrap_TheColourDatabase_set(PyObject *) {
20935     PyErr_SetString(PyExc_TypeError,"Variable TheColourDatabase is read-only.");
20936     return 1;
20937 }
20938
20939
20940 static PyObject *_wrap_TheColourDatabase_get(void) {
20941     PyObject *pyobj;
20942
20943     pyobj = SWIG_NewPointerObj((void *)(wxTheColourDatabase), SWIGTYPE_p_wxColourDatabase, 0);
20944     return pyobj;
20945 }
20946
20947
20948 static PyObject *_wrap_new_Effects(PyObject *, PyObject *args, PyObject *kwargs) {
20949     PyObject *resultobj;
20950     wxEffects *result;
20951     char *kwnames[] = {
20952         NULL
20953     };
20954
20955     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Effects",kwnames)) goto fail;
20956     {
20957         PyThreadState* __tstate = wxPyBeginAllowThreads();
20958         result = (wxEffects *)new wxEffects();
20959
20960         wxPyEndAllowThreads(__tstate);
20961         if (PyErr_Occurred()) SWIG_fail;
20962     }
20963     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEffects, 1);
20964     return resultobj;
20965     fail:
20966     return NULL;
20967 }
20968
20969
20970 static PyObject *_wrap_Effects_GetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
20971     PyObject *resultobj;
20972     wxEffects *arg1 = (wxEffects *) 0 ;
20973     wxColour result;
20974     PyObject * obj0 = 0 ;
20975     char *kwnames[] = {
20976         (char *) "self", NULL
20977     };
20978
20979     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetHighlightColour",kwnames,&obj0)) goto fail;
20980     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20981     if (SWIG_arg_fail(1)) SWIG_fail;
20982     {
20983         PyThreadState* __tstate = wxPyBeginAllowThreads();
20984         result = ((wxEffects const *)arg1)->GetHighlightColour();
20985
20986         wxPyEndAllowThreads(__tstate);
20987         if (PyErr_Occurred()) SWIG_fail;
20988     }
20989     {
20990         wxColour * resultptr;
20991         resultptr = new wxColour((wxColour &)(result));
20992         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20993     }
20994     return resultobj;
20995     fail:
20996     return NULL;
20997 }
20998
20999
21000 static PyObject *_wrap_Effects_GetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21001     PyObject *resultobj;
21002     wxEffects *arg1 = (wxEffects *) 0 ;
21003     wxColour result;
21004     PyObject * obj0 = 0 ;
21005     char *kwnames[] = {
21006         (char *) "self", NULL
21007     };
21008
21009     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetLightShadow",kwnames,&obj0)) goto fail;
21010     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21011     if (SWIG_arg_fail(1)) SWIG_fail;
21012     {
21013         PyThreadState* __tstate = wxPyBeginAllowThreads();
21014         result = ((wxEffects const *)arg1)->GetLightShadow();
21015
21016         wxPyEndAllowThreads(__tstate);
21017         if (PyErr_Occurred()) SWIG_fail;
21018     }
21019     {
21020         wxColour * resultptr;
21021         resultptr = new wxColour((wxColour &)(result));
21022         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
21023     }
21024     return resultobj;
21025     fail:
21026     return NULL;
21027 }
21028
21029
21030 static PyObject *_wrap_Effects_GetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
21031     PyObject *resultobj;
21032     wxEffects *arg1 = (wxEffects *) 0 ;
21033     wxColour result;
21034     PyObject * obj0 = 0 ;
21035     char *kwnames[] = {
21036         (char *) "self", NULL
21037     };
21038
21039     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetFaceColour",kwnames,&obj0)) goto fail;
21040     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21041     if (SWIG_arg_fail(1)) SWIG_fail;
21042     {
21043         PyThreadState* __tstate = wxPyBeginAllowThreads();
21044         result = ((wxEffects const *)arg1)->GetFaceColour();
21045
21046         wxPyEndAllowThreads(__tstate);
21047         if (PyErr_Occurred()) SWIG_fail;
21048     }
21049     {
21050         wxColour * resultptr;
21051         resultptr = new wxColour((wxColour &)(result));
21052         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
21053     }
21054     return resultobj;
21055     fail:
21056     return NULL;
21057 }
21058
21059
21060 static PyObject *_wrap_Effects_GetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21061     PyObject *resultobj;
21062     wxEffects *arg1 = (wxEffects *) 0 ;
21063     wxColour result;
21064     PyObject * obj0 = 0 ;
21065     char *kwnames[] = {
21066         (char *) "self", NULL
21067     };
21068
21069     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetMediumShadow",kwnames,&obj0)) goto fail;
21070     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21071     if (SWIG_arg_fail(1)) SWIG_fail;
21072     {
21073         PyThreadState* __tstate = wxPyBeginAllowThreads();
21074         result = ((wxEffects const *)arg1)->GetMediumShadow();
21075
21076         wxPyEndAllowThreads(__tstate);
21077         if (PyErr_Occurred()) SWIG_fail;
21078     }
21079     {
21080         wxColour * resultptr;
21081         resultptr = new wxColour((wxColour &)(result));
21082         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
21083     }
21084     return resultobj;
21085     fail:
21086     return NULL;
21087 }
21088
21089
21090 static PyObject *_wrap_Effects_GetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21091     PyObject *resultobj;
21092     wxEffects *arg1 = (wxEffects *) 0 ;
21093     wxColour result;
21094     PyObject * obj0 = 0 ;
21095     char *kwnames[] = {
21096         (char *) "self", NULL
21097     };
21098
21099     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetDarkShadow",kwnames,&obj0)) goto fail;
21100     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21101     if (SWIG_arg_fail(1)) SWIG_fail;
21102     {
21103         PyThreadState* __tstate = wxPyBeginAllowThreads();
21104         result = ((wxEffects const *)arg1)->GetDarkShadow();
21105
21106         wxPyEndAllowThreads(__tstate);
21107         if (PyErr_Occurred()) SWIG_fail;
21108     }
21109     {
21110         wxColour * resultptr;
21111         resultptr = new wxColour((wxColour &)(result));
21112         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
21113     }
21114     return resultobj;
21115     fail:
21116     return NULL;
21117 }
21118
21119
21120 static PyObject *_wrap_Effects_SetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
21121     PyObject *resultobj;
21122     wxEffects *arg1 = (wxEffects *) 0 ;
21123     wxColour *arg2 = 0 ;
21124     wxColour temp2 ;
21125     PyObject * obj0 = 0 ;
21126     PyObject * obj1 = 0 ;
21127     char *kwnames[] = {
21128         (char *) "self",(char *) "c", NULL
21129     };
21130
21131     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetHighlightColour",kwnames,&obj0,&obj1)) goto fail;
21132     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21133     if (SWIG_arg_fail(1)) SWIG_fail;
21134     {
21135         arg2 = &temp2;
21136         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21137     }
21138     {
21139         PyThreadState* __tstate = wxPyBeginAllowThreads();
21140         (arg1)->SetHighlightColour((wxColour const &)*arg2);
21141
21142         wxPyEndAllowThreads(__tstate);
21143         if (PyErr_Occurred()) SWIG_fail;
21144     }
21145     Py_INCREF(Py_None); resultobj = Py_None;
21146     return resultobj;
21147     fail:
21148     return NULL;
21149 }
21150
21151
21152 static PyObject *_wrap_Effects_SetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21153     PyObject *resultobj;
21154     wxEffects *arg1 = (wxEffects *) 0 ;
21155     wxColour *arg2 = 0 ;
21156     wxColour temp2 ;
21157     PyObject * obj0 = 0 ;
21158     PyObject * obj1 = 0 ;
21159     char *kwnames[] = {
21160         (char *) "self",(char *) "c", NULL
21161     };
21162
21163     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetLightShadow",kwnames,&obj0,&obj1)) goto fail;
21164     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21165     if (SWIG_arg_fail(1)) SWIG_fail;
21166     {
21167         arg2 = &temp2;
21168         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21169     }
21170     {
21171         PyThreadState* __tstate = wxPyBeginAllowThreads();
21172         (arg1)->SetLightShadow((wxColour const &)*arg2);
21173
21174         wxPyEndAllowThreads(__tstate);
21175         if (PyErr_Occurred()) SWIG_fail;
21176     }
21177     Py_INCREF(Py_None); resultobj = Py_None;
21178     return resultobj;
21179     fail:
21180     return NULL;
21181 }
21182
21183
21184 static PyObject *_wrap_Effects_SetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
21185     PyObject *resultobj;
21186     wxEffects *arg1 = (wxEffects *) 0 ;
21187     wxColour *arg2 = 0 ;
21188     wxColour temp2 ;
21189     PyObject * obj0 = 0 ;
21190     PyObject * obj1 = 0 ;
21191     char *kwnames[] = {
21192         (char *) "self",(char *) "c", NULL
21193     };
21194
21195     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetFaceColour",kwnames,&obj0,&obj1)) goto fail;
21196     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21197     if (SWIG_arg_fail(1)) SWIG_fail;
21198     {
21199         arg2 = &temp2;
21200         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21201     }
21202     {
21203         PyThreadState* __tstate = wxPyBeginAllowThreads();
21204         (arg1)->SetFaceColour((wxColour const &)*arg2);
21205
21206         wxPyEndAllowThreads(__tstate);
21207         if (PyErr_Occurred()) SWIG_fail;
21208     }
21209     Py_INCREF(Py_None); resultobj = Py_None;
21210     return resultobj;
21211     fail:
21212     return NULL;
21213 }
21214
21215
21216 static PyObject *_wrap_Effects_SetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21217     PyObject *resultobj;
21218     wxEffects *arg1 = (wxEffects *) 0 ;
21219     wxColour *arg2 = 0 ;
21220     wxColour temp2 ;
21221     PyObject * obj0 = 0 ;
21222     PyObject * obj1 = 0 ;
21223     char *kwnames[] = {
21224         (char *) "self",(char *) "c", NULL
21225     };
21226
21227     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetMediumShadow",kwnames,&obj0,&obj1)) goto fail;
21228     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21229     if (SWIG_arg_fail(1)) SWIG_fail;
21230     {
21231         arg2 = &temp2;
21232         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21233     }
21234     {
21235         PyThreadState* __tstate = wxPyBeginAllowThreads();
21236         (arg1)->SetMediumShadow((wxColour const &)*arg2);
21237
21238         wxPyEndAllowThreads(__tstate);
21239         if (PyErr_Occurred()) SWIG_fail;
21240     }
21241     Py_INCREF(Py_None); resultobj = Py_None;
21242     return resultobj;
21243     fail:
21244     return NULL;
21245 }
21246
21247
21248 static PyObject *_wrap_Effects_SetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21249     PyObject *resultobj;
21250     wxEffects *arg1 = (wxEffects *) 0 ;
21251     wxColour *arg2 = 0 ;
21252     wxColour temp2 ;
21253     PyObject * obj0 = 0 ;
21254     PyObject * obj1 = 0 ;
21255     char *kwnames[] = {
21256         (char *) "self",(char *) "c", NULL
21257     };
21258
21259     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetDarkShadow",kwnames,&obj0,&obj1)) goto fail;
21260     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21261     if (SWIG_arg_fail(1)) SWIG_fail;
21262     {
21263         arg2 = &temp2;
21264         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21265     }
21266     {
21267         PyThreadState* __tstate = wxPyBeginAllowThreads();
21268         (arg1)->SetDarkShadow((wxColour const &)*arg2);
21269
21270         wxPyEndAllowThreads(__tstate);
21271         if (PyErr_Occurred()) SWIG_fail;
21272     }
21273     Py_INCREF(Py_None); resultobj = Py_None;
21274     return resultobj;
21275     fail:
21276     return NULL;
21277 }
21278
21279
21280 static PyObject *_wrap_Effects_Set(PyObject *, PyObject *args, PyObject *kwargs) {
21281     PyObject *resultobj;
21282     wxEffects *arg1 = (wxEffects *) 0 ;
21283     wxColour *arg2 = 0 ;
21284     wxColour *arg3 = 0 ;
21285     wxColour *arg4 = 0 ;
21286     wxColour *arg5 = 0 ;
21287     wxColour *arg6 = 0 ;
21288     wxColour temp2 ;
21289     wxColour temp3 ;
21290     wxColour temp4 ;
21291     wxColour temp5 ;
21292     wxColour temp6 ;
21293     PyObject * obj0 = 0 ;
21294     PyObject * obj1 = 0 ;
21295     PyObject * obj2 = 0 ;
21296     PyObject * obj3 = 0 ;
21297     PyObject * obj4 = 0 ;
21298     PyObject * obj5 = 0 ;
21299     char *kwnames[] = {
21300         (char *) "self",(char *) "highlightColour",(char *) "lightShadow",(char *) "faceColour",(char *) "mediumShadow",(char *) "darkShadow", NULL
21301     };
21302
21303     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Effects_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
21304     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21305     if (SWIG_arg_fail(1)) SWIG_fail;
21306     {
21307         arg2 = &temp2;
21308         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21309     }
21310     {
21311         arg3 = &temp3;
21312         if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
21313     }
21314     {
21315         arg4 = &temp4;
21316         if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
21317     }
21318     {
21319         arg5 = &temp5;
21320         if ( ! wxColour_helper(obj4, &arg5)) SWIG_fail;
21321     }
21322     {
21323         arg6 = &temp6;
21324         if ( ! wxColour_helper(obj5, &arg6)) SWIG_fail;
21325     }
21326     {
21327         PyThreadState* __tstate = wxPyBeginAllowThreads();
21328         (arg1)->Set((wxColour const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,(wxColour const &)*arg5,(wxColour const &)*arg6);
21329
21330         wxPyEndAllowThreads(__tstate);
21331         if (PyErr_Occurred()) SWIG_fail;
21332     }
21333     Py_INCREF(Py_None); resultobj = Py_None;
21334     return resultobj;
21335     fail:
21336     return NULL;
21337 }
21338
21339
21340 static PyObject *_wrap_Effects_DrawSunkenEdge(PyObject *, PyObject *args, PyObject *kwargs) {
21341     PyObject *resultobj;
21342     wxEffects *arg1 = (wxEffects *) 0 ;
21343     wxDC *arg2 = 0 ;
21344     wxRect *arg3 = 0 ;
21345     int arg4 = (int) 1 ;
21346     wxRect temp3 ;
21347     PyObject * obj0 = 0 ;
21348     PyObject * obj1 = 0 ;
21349     PyObject * obj2 = 0 ;
21350     PyObject * obj3 = 0 ;
21351     char *kwnames[] = {
21352         (char *) "self",(char *) "dc",(char *) "rect",(char *) "borderSize", NULL
21353     };
21354
21355     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Effects_DrawSunkenEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21356     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21357     if (SWIG_arg_fail(1)) SWIG_fail;
21358     {
21359         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21360         if (SWIG_arg_fail(2)) SWIG_fail;
21361         if (arg2 == NULL) {
21362             SWIG_null_ref("wxDC");
21363         }
21364         if (SWIG_arg_fail(2)) SWIG_fail;
21365     }
21366     {
21367         arg3 = &temp3;
21368         if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
21369     }
21370     if (obj3) {
21371         {
21372             arg4 = (int)(SWIG_As_int(obj3));
21373             if (SWIG_arg_fail(4)) SWIG_fail;
21374         }
21375     }
21376     {
21377         PyThreadState* __tstate = wxPyBeginAllowThreads();
21378         (arg1)->DrawSunkenEdge(*arg2,(wxRect const &)*arg3,arg4);
21379
21380         wxPyEndAllowThreads(__tstate);
21381         if (PyErr_Occurred()) SWIG_fail;
21382     }
21383     Py_INCREF(Py_None); resultobj = Py_None;
21384     return resultobj;
21385     fail:
21386     return NULL;
21387 }
21388
21389
21390 static PyObject *_wrap_Effects_TileBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
21391     PyObject *resultobj;
21392     wxEffects *arg1 = (wxEffects *) 0 ;
21393     wxRect *arg2 = 0 ;
21394     wxDC *arg3 = 0 ;
21395     wxBitmap *arg4 = 0 ;
21396     bool result;
21397     wxRect temp2 ;
21398     PyObject * obj0 = 0 ;
21399     PyObject * obj1 = 0 ;
21400     PyObject * obj2 = 0 ;
21401     PyObject * obj3 = 0 ;
21402     char *kwnames[] = {
21403         (char *) "self",(char *) "rect",(char *) "dc",(char *) "bitmap", NULL
21404     };
21405
21406     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Effects_TileBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21407     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21408     if (SWIG_arg_fail(1)) SWIG_fail;
21409     {
21410         arg2 = &temp2;
21411         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
21412     }
21413     {
21414         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21415         if (SWIG_arg_fail(3)) SWIG_fail;
21416         if (arg3 == NULL) {
21417             SWIG_null_ref("wxDC");
21418         }
21419         if (SWIG_arg_fail(3)) SWIG_fail;
21420     }
21421     {
21422         SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
21423         if (SWIG_arg_fail(4)) SWIG_fail;
21424         if (arg4 == NULL) {
21425             SWIG_null_ref("wxBitmap");
21426         }
21427         if (SWIG_arg_fail(4)) SWIG_fail;
21428     }
21429     {
21430         PyThreadState* __tstate = wxPyBeginAllowThreads();
21431         result = (bool)(arg1)->TileBitmap((wxRect const &)*arg2,*arg3,*arg4);
21432
21433         wxPyEndAllowThreads(__tstate);
21434         if (PyErr_Occurred()) SWIG_fail;
21435     }
21436     {
21437         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21438     }
21439     return resultobj;
21440     fail:
21441     return NULL;
21442 }
21443
21444
21445 static PyObject * Effects_swigregister(PyObject *, PyObject *args) {
21446     PyObject *obj;
21447     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21448     SWIG_TypeClientData(SWIGTYPE_p_wxEffects, obj);
21449     Py_INCREF(obj);
21450     return Py_BuildValue((char *)"");
21451 }
21452 static PyMethodDef SwigMethods[] = {
21453          { (char *)"new_GDIObject", (PyCFunction) _wrap_new_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
21454          { (char *)"delete_GDIObject", (PyCFunction) _wrap_delete_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
21455          { (char *)"GDIObject_GetVisible", (PyCFunction) _wrap_GDIObject_GetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
21456          { (char *)"GDIObject_SetVisible", (PyCFunction) _wrap_GDIObject_SetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
21457          { (char *)"GDIObject_IsNull", (PyCFunction) _wrap_GDIObject_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
21458          { (char *)"GDIObject_swigregister", GDIObject_swigregister, METH_VARARGS, NULL},
21459          { (char *)"new_Colour", (PyCFunction) _wrap_new_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
21460          { (char *)"new_NamedColour", (PyCFunction) _wrap_new_NamedColour, METH_VARARGS | METH_KEYWORDS, NULL},
21461          { (char *)"new_ColourRGB", (PyCFunction) _wrap_new_ColourRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21462          { (char *)"delete_Colour", (PyCFunction) _wrap_delete_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
21463          { (char *)"Colour_Red", (PyCFunction) _wrap_Colour_Red, METH_VARARGS | METH_KEYWORDS, NULL},
21464          { (char *)"Colour_Green", (PyCFunction) _wrap_Colour_Green, METH_VARARGS | METH_KEYWORDS, NULL},
21465          { (char *)"Colour_Blue", (PyCFunction) _wrap_Colour_Blue, METH_VARARGS | METH_KEYWORDS, NULL},
21466          { (char *)"Colour_Ok", (PyCFunction) _wrap_Colour_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21467          { (char *)"Colour_Set", (PyCFunction) _wrap_Colour_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21468          { (char *)"Colour_SetRGB", (PyCFunction) _wrap_Colour_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21469          { (char *)"Colour_SetFromName", (PyCFunction) _wrap_Colour_SetFromName, METH_VARARGS | METH_KEYWORDS, NULL},
21470          { (char *)"Colour_GetPixel", (PyCFunction) _wrap_Colour_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
21471          { (char *)"Colour___eq__", (PyCFunction) _wrap_Colour___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21472          { (char *)"Colour___ne__", (PyCFunction) _wrap_Colour___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21473          { (char *)"Colour_Get", (PyCFunction) _wrap_Colour_Get, METH_VARARGS | METH_KEYWORDS, NULL},
21474          { (char *)"Colour_GetRGB", (PyCFunction) _wrap_Colour_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21475          { (char *)"Colour_swigregister", Colour_swigregister, METH_VARARGS, NULL},
21476          { (char *)"new_Palette", (PyCFunction) _wrap_new_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
21477          { (char *)"delete_Palette", (PyCFunction) _wrap_delete_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
21478          { (char *)"Palette_GetPixel", (PyCFunction) _wrap_Palette_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
21479          { (char *)"Palette_GetRGB", (PyCFunction) _wrap_Palette_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21480          { (char *)"Palette_GetColoursCount", (PyCFunction) _wrap_Palette_GetColoursCount, METH_VARARGS | METH_KEYWORDS, NULL},
21481          { (char *)"Palette_Ok", (PyCFunction) _wrap_Palette_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21482          { (char *)"Palette_swigregister", Palette_swigregister, METH_VARARGS, NULL},
21483          { (char *)"new_Pen", (PyCFunction) _wrap_new_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
21484          { (char *)"delete_Pen", (PyCFunction) _wrap_delete_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
21485          { (char *)"Pen_GetCap", (PyCFunction) _wrap_Pen_GetCap, METH_VARARGS | METH_KEYWORDS, NULL},
21486          { (char *)"Pen_GetColour", (PyCFunction) _wrap_Pen_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21487          { (char *)"Pen_GetJoin", (PyCFunction) _wrap_Pen_GetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
21488          { (char *)"Pen_GetStyle", (PyCFunction) _wrap_Pen_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21489          { (char *)"Pen_GetWidth", (PyCFunction) _wrap_Pen_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21490          { (char *)"Pen_Ok", (PyCFunction) _wrap_Pen_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21491          { (char *)"Pen_SetCap", (PyCFunction) _wrap_Pen_SetCap, METH_VARARGS | METH_KEYWORDS, NULL},
21492          { (char *)"Pen_SetColour", (PyCFunction) _wrap_Pen_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21493          { (char *)"Pen_SetJoin", (PyCFunction) _wrap_Pen_SetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
21494          { (char *)"Pen_SetStyle", (PyCFunction) _wrap_Pen_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21495          { (char *)"Pen_SetWidth", (PyCFunction) _wrap_Pen_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21496          { (char *)"Pen_SetDashes", (PyCFunction) _wrap_Pen_SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
21497          { (char *)"Pen_GetDashes", (PyCFunction) _wrap_Pen_GetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
21498          { (char *)"Pen__SetDashes", (PyCFunction) _wrap_Pen__SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
21499          { (char *)"Pen_GetDashCount", (PyCFunction) _wrap_Pen_GetDashCount, METH_VARARGS | METH_KEYWORDS, NULL},
21500          { (char *)"Pen_GetStipple", (PyCFunction) _wrap_Pen_GetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
21501          { (char *)"Pen_SetStipple", (PyCFunction) _wrap_Pen_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
21502          { (char *)"Pen___eq__", (PyCFunction) _wrap_Pen___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21503          { (char *)"Pen___ne__", (PyCFunction) _wrap_Pen___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21504          { (char *)"Pen_swigregister", Pen_swigregister, METH_VARARGS, NULL},
21505          { (char *)"new_Brush", (PyCFunction) _wrap_new_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
21506          { (char *)"new_BrushFromBitmap", (PyCFunction) _wrap_new_BrushFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21507          { (char *)"delete_Brush", (PyCFunction) _wrap_delete_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
21508          { (char *)"Brush_SetColour", (PyCFunction) _wrap_Brush_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21509          { (char *)"Brush_SetStyle", (PyCFunction) _wrap_Brush_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21510          { (char *)"Brush_SetStipple", (PyCFunction) _wrap_Brush_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
21511          { (char *)"Brush_GetColour", (PyCFunction) _wrap_Brush_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21512          { (char *)"Brush_GetStyle", (PyCFunction) _wrap_Brush_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21513          { (char *)"Brush_GetStipple", (PyCFunction) _wrap_Brush_GetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
21514          { (char *)"Brush_IsHatch", (PyCFunction) _wrap_Brush_IsHatch, METH_VARARGS | METH_KEYWORDS, NULL},
21515          { (char *)"Brush_Ok", (PyCFunction) _wrap_Brush_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21516          { (char *)"Brush_swigregister", Brush_swigregister, METH_VARARGS, NULL},
21517          { (char *)"new_Bitmap", (PyCFunction) _wrap_new_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21518          { (char *)"delete_Bitmap", (PyCFunction) _wrap_delete_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21519          { (char *)"new_EmptyBitmap", (PyCFunction) _wrap_new_EmptyBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21520          { (char *)"new_BitmapFromIcon", (PyCFunction) _wrap_new_BitmapFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21521          { (char *)"new_BitmapFromImage", (PyCFunction) _wrap_new_BitmapFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
21522          { (char *)"new_BitmapFromXPMData", (PyCFunction) _wrap_new_BitmapFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
21523          { (char *)"new_BitmapFromBits", (PyCFunction) _wrap_new_BitmapFromBits, METH_VARARGS | METH_KEYWORDS, NULL},
21524          { (char *)"Bitmap_GetHandle", (PyCFunction) _wrap_Bitmap_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
21525          { (char *)"Bitmap_SetHandle", (PyCFunction) _wrap_Bitmap_SetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
21526          { (char *)"Bitmap_Ok", (PyCFunction) _wrap_Bitmap_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21527          { (char *)"Bitmap_GetWidth", (PyCFunction) _wrap_Bitmap_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21528          { (char *)"Bitmap_GetHeight", (PyCFunction) _wrap_Bitmap_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21529          { (char *)"Bitmap_GetDepth", (PyCFunction) _wrap_Bitmap_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21530          { (char *)"Bitmap_GetSize", (PyCFunction) _wrap_Bitmap_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21531          { (char *)"Bitmap_ConvertToImage", (PyCFunction) _wrap_Bitmap_ConvertToImage, METH_VARARGS | METH_KEYWORDS, NULL},
21532          { (char *)"Bitmap_GetMask", (PyCFunction) _wrap_Bitmap_GetMask, METH_VARARGS | METH_KEYWORDS, NULL},
21533          { (char *)"Bitmap_SetMask", (PyCFunction) _wrap_Bitmap_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
21534          { (char *)"Bitmap_SetMaskColour", (PyCFunction) _wrap_Bitmap_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
21535          { (char *)"Bitmap_GetSubBitmap", (PyCFunction) _wrap_Bitmap_GetSubBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21536          { (char *)"Bitmap_SaveFile", (PyCFunction) _wrap_Bitmap_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
21537          { (char *)"Bitmap_LoadFile", (PyCFunction) _wrap_Bitmap_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
21538          { (char *)"Bitmap_GetPalette", (PyCFunction) _wrap_Bitmap_GetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
21539          { (char *)"Bitmap_SetPalette", (PyCFunction) _wrap_Bitmap_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
21540          { (char *)"Bitmap_CopyFromIcon", (PyCFunction) _wrap_Bitmap_CopyFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21541          { (char *)"Bitmap_SetHeight", (PyCFunction) _wrap_Bitmap_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21542          { (char *)"Bitmap_SetWidth", (PyCFunction) _wrap_Bitmap_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21543          { (char *)"Bitmap_SetDepth", (PyCFunction) _wrap_Bitmap_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21544          { (char *)"Bitmap_SetSize", (PyCFunction) _wrap_Bitmap_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21545          { (char *)"Bitmap_CopyFromCursor", (PyCFunction) _wrap_Bitmap_CopyFromCursor, METH_VARARGS | METH_KEYWORDS, NULL},
21546          { (char *)"Bitmap_GetQuality", (PyCFunction) _wrap_Bitmap_GetQuality, METH_VARARGS | METH_KEYWORDS, NULL},
21547          { (char *)"Bitmap_SetQuality", (PyCFunction) _wrap_Bitmap_SetQuality, METH_VARARGS | METH_KEYWORDS, NULL},
21548          { (char *)"Bitmap___eq__", (PyCFunction) _wrap_Bitmap___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21549          { (char *)"Bitmap___ne__", (PyCFunction) _wrap_Bitmap___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21550          { (char *)"Bitmap_swigregister", Bitmap_swigregister, METH_VARARGS, NULL},
21551          { (char *)"new_Mask", (PyCFunction) _wrap_new_Mask, METH_VARARGS | METH_KEYWORDS, NULL},
21552          { (char *)"Mask_swigregister", Mask_swigregister, METH_VARARGS, NULL},
21553          { (char *)"new_Icon", (PyCFunction) _wrap_new_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
21554          { (char *)"delete_Icon", (PyCFunction) _wrap_delete_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
21555          { (char *)"new_EmptyIcon", (PyCFunction) _wrap_new_EmptyIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21556          { (char *)"new_IconFromLocation", (PyCFunction) _wrap_new_IconFromLocation, METH_VARARGS | METH_KEYWORDS, NULL},
21557          { (char *)"new_IconFromBitmap", (PyCFunction) _wrap_new_IconFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21558          { (char *)"new_IconFromXPMData", (PyCFunction) _wrap_new_IconFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
21559          { (char *)"Icon_LoadFile", (PyCFunction) _wrap_Icon_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
21560          { (char *)"Icon_GetHandle", (PyCFunction) _wrap_Icon_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
21561          { (char *)"Icon_SetHandle", (PyCFunction) _wrap_Icon_SetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
21562          { (char *)"Icon_Ok", (PyCFunction) _wrap_Icon_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21563          { (char *)"Icon_GetWidth", (PyCFunction) _wrap_Icon_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21564          { (char *)"Icon_GetHeight", (PyCFunction) _wrap_Icon_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21565          { (char *)"Icon_GetDepth", (PyCFunction) _wrap_Icon_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21566          { (char *)"Icon_SetWidth", (PyCFunction) _wrap_Icon_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21567          { (char *)"Icon_SetHeight", (PyCFunction) _wrap_Icon_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21568          { (char *)"Icon_SetDepth", (PyCFunction) _wrap_Icon_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21569          { (char *)"Icon_SetSize", (PyCFunction) _wrap_Icon_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21570          { (char *)"Icon_CopyFromBitmap", (PyCFunction) _wrap_Icon_CopyFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21571          { (char *)"Icon_swigregister", Icon_swigregister, METH_VARARGS, NULL},
21572          { (char *)"new_IconLocation", (PyCFunction) _wrap_new_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
21573          { (char *)"delete_IconLocation", (PyCFunction) _wrap_delete_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
21574          { (char *)"IconLocation_IsOk", (PyCFunction) _wrap_IconLocation_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
21575          { (char *)"IconLocation_SetFileName", (PyCFunction) _wrap_IconLocation_SetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
21576          { (char *)"IconLocation_GetFileName", (PyCFunction) _wrap_IconLocation_GetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
21577          { (char *)"IconLocation_SetIndex", (PyCFunction) _wrap_IconLocation_SetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
21578          { (char *)"IconLocation_GetIndex", (PyCFunction) _wrap_IconLocation_GetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
21579          { (char *)"IconLocation_swigregister", IconLocation_swigregister, METH_VARARGS, NULL},
21580          { (char *)"new_IconBundle", (PyCFunction) _wrap_new_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
21581          { (char *)"new_IconBundleFromFile", (PyCFunction) _wrap_new_IconBundleFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
21582          { (char *)"new_IconBundleFromIcon", (PyCFunction) _wrap_new_IconBundleFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21583          { (char *)"delete_IconBundle", (PyCFunction) _wrap_delete_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
21584          { (char *)"IconBundle_AddIcon", (PyCFunction) _wrap_IconBundle_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21585          { (char *)"IconBundle_AddIconFromFile", (PyCFunction) _wrap_IconBundle_AddIconFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
21586          { (char *)"IconBundle_GetIcon", (PyCFunction) _wrap_IconBundle_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21587          { (char *)"IconBundle_swigregister", IconBundle_swigregister, METH_VARARGS, NULL},
21588          { (char *)"new_Cursor", (PyCFunction) _wrap_new_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
21589          { (char *)"delete_Cursor", (PyCFunction) _wrap_delete_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
21590          { (char *)"new_StockCursor", (PyCFunction) _wrap_new_StockCursor, METH_VARARGS | METH_KEYWORDS, NULL},
21591          { (char *)"new_CursorFromImage", (PyCFunction) _wrap_new_CursorFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
21592          { (char *)"Cursor_GetHandle", (PyCFunction) _wrap_Cursor_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
21593          { (char *)"Cursor_SetHandle", (PyCFunction) _wrap_Cursor_SetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
21594          { (char *)"Cursor_Ok", (PyCFunction) _wrap_Cursor_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21595          { (char *)"Cursor_GetWidth", (PyCFunction) _wrap_Cursor_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21596          { (char *)"Cursor_GetHeight", (PyCFunction) _wrap_Cursor_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21597          { (char *)"Cursor_GetDepth", (PyCFunction) _wrap_Cursor_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21598          { (char *)"Cursor_SetWidth", (PyCFunction) _wrap_Cursor_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21599          { (char *)"Cursor_SetHeight", (PyCFunction) _wrap_Cursor_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21600          { (char *)"Cursor_SetDepth", (PyCFunction) _wrap_Cursor_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21601          { (char *)"Cursor_SetSize", (PyCFunction) _wrap_Cursor_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21602          { (char *)"Cursor_swigregister", Cursor_swigregister, METH_VARARGS, NULL},
21603          { (char *)"new_Region", (PyCFunction) _wrap_new_Region, METH_VARARGS | METH_KEYWORDS, NULL},
21604          { (char *)"new_RegionFromBitmap", (PyCFunction) _wrap_new_RegionFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21605          { (char *)"new_RegionFromBitmapColour", (PyCFunction) _wrap_new_RegionFromBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
21606          { (char *)"new_RegionFromPoints", (PyCFunction) _wrap_new_RegionFromPoints, METH_VARARGS | METH_KEYWORDS, NULL},
21607          { (char *)"delete_Region", (PyCFunction) _wrap_delete_Region, METH_VARARGS | METH_KEYWORDS, NULL},
21608          { (char *)"Region_Clear", (PyCFunction) _wrap_Region_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
21609          { (char *)"Region_Offset", (PyCFunction) _wrap_Region_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
21610          { (char *)"Region_Contains", (PyCFunction) _wrap_Region_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
21611          { (char *)"Region_ContainsPoint", (PyCFunction) _wrap_Region_ContainsPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21612          { (char *)"Region_ContainsRect", (PyCFunction) _wrap_Region_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
21613          { (char *)"Region_ContainsRectDim", (PyCFunction) _wrap_Region_ContainsRectDim, METH_VARARGS | METH_KEYWORDS, NULL},
21614          { (char *)"Region_GetBox", (PyCFunction) _wrap_Region_GetBox, METH_VARARGS | METH_KEYWORDS, NULL},
21615          { (char *)"Region_Intersect", (PyCFunction) _wrap_Region_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
21616          { (char *)"Region_IntersectRect", (PyCFunction) _wrap_Region_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
21617          { (char *)"Region_IntersectRegion", (PyCFunction) _wrap_Region_IntersectRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21618          { (char *)"Region_IsEmpty", (PyCFunction) _wrap_Region_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
21619          { (char *)"Region_Union", (PyCFunction) _wrap_Region_Union, METH_VARARGS | METH_KEYWORDS, NULL},
21620          { (char *)"Region_UnionRect", (PyCFunction) _wrap_Region_UnionRect, METH_VARARGS | METH_KEYWORDS, NULL},
21621          { (char *)"Region_UnionRegion", (PyCFunction) _wrap_Region_UnionRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21622          { (char *)"Region_Subtract", (PyCFunction) _wrap_Region_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
21623          { (char *)"Region_SubtractRect", (PyCFunction) _wrap_Region_SubtractRect, METH_VARARGS | METH_KEYWORDS, NULL},
21624          { (char *)"Region_SubtractRegion", (PyCFunction) _wrap_Region_SubtractRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21625          { (char *)"Region_Xor", (PyCFunction) _wrap_Region_Xor, METH_VARARGS | METH_KEYWORDS, NULL},
21626          { (char *)"Region_XorRect", (PyCFunction) _wrap_Region_XorRect, METH_VARARGS | METH_KEYWORDS, NULL},
21627          { (char *)"Region_XorRegion", (PyCFunction) _wrap_Region_XorRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21628          { (char *)"Region_ConvertToBitmap", (PyCFunction) _wrap_Region_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21629          { (char *)"Region_UnionBitmap", (PyCFunction) _wrap_Region_UnionBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21630          { (char *)"Region_UnionBitmapColour", (PyCFunction) _wrap_Region_UnionBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
21631          { (char *)"Region_swigregister", Region_swigregister, METH_VARARGS, NULL},
21632          { (char *)"new_RegionIterator", (PyCFunction) _wrap_new_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
21633          { (char *)"delete_RegionIterator", (PyCFunction) _wrap_delete_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
21634          { (char *)"RegionIterator_GetX", (PyCFunction) _wrap_RegionIterator_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
21635          { (char *)"RegionIterator_GetY", (PyCFunction) _wrap_RegionIterator_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
21636          { (char *)"RegionIterator_GetW", (PyCFunction) _wrap_RegionIterator_GetW, METH_VARARGS | METH_KEYWORDS, NULL},
21637          { (char *)"RegionIterator_GetWidth", (PyCFunction) _wrap_RegionIterator_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21638          { (char *)"RegionIterator_GetH", (PyCFunction) _wrap_RegionIterator_GetH, METH_VARARGS | METH_KEYWORDS, NULL},
21639          { (char *)"RegionIterator_GetHeight", (PyCFunction) _wrap_RegionIterator_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21640          { (char *)"RegionIterator_GetRect", (PyCFunction) _wrap_RegionIterator_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
21641          { (char *)"RegionIterator_HaveRects", (PyCFunction) _wrap_RegionIterator_HaveRects, METH_VARARGS | METH_KEYWORDS, NULL},
21642          { (char *)"RegionIterator_Reset", (PyCFunction) _wrap_RegionIterator_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
21643          { (char *)"RegionIterator_Next", (PyCFunction) _wrap_RegionIterator_Next, METH_VARARGS | METH_KEYWORDS, NULL},
21644          { (char *)"RegionIterator___nonzero__", (PyCFunction) _wrap_RegionIterator___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
21645          { (char *)"RegionIterator_swigregister", RegionIterator_swigregister, METH_VARARGS, NULL},
21646          { (char *)"new_NativeFontInfo", (PyCFunction) _wrap_new_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21647          { (char *)"delete_NativeFontInfo", (PyCFunction) _wrap_delete_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21648          { (char *)"NativeFontInfo_Init", (PyCFunction) _wrap_NativeFontInfo_Init, METH_VARARGS | METH_KEYWORDS, NULL},
21649          { (char *)"NativeFontInfo_InitFromFont", (PyCFunction) _wrap_NativeFontInfo_InitFromFont, METH_VARARGS | METH_KEYWORDS, NULL},
21650          { (char *)"NativeFontInfo_GetPointSize", (PyCFunction) _wrap_NativeFontInfo_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21651          { (char *)"NativeFontInfo_GetPixelSize", (PyCFunction) _wrap_NativeFontInfo_GetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21652          { (char *)"NativeFontInfo_GetStyle", (PyCFunction) _wrap_NativeFontInfo_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21653          { (char *)"NativeFontInfo_GetWeight", (PyCFunction) _wrap_NativeFontInfo_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21654          { (char *)"NativeFontInfo_GetUnderlined", (PyCFunction) _wrap_NativeFontInfo_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21655          { (char *)"NativeFontInfo_GetFaceName", (PyCFunction) _wrap_NativeFontInfo_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21656          { (char *)"NativeFontInfo_GetFamily", (PyCFunction) _wrap_NativeFontInfo_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21657          { (char *)"NativeFontInfo_GetEncoding", (PyCFunction) _wrap_NativeFontInfo_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21658          { (char *)"NativeFontInfo_SetPointSize", (PyCFunction) _wrap_NativeFontInfo_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21659          { (char *)"NativeFontInfo_SetPixelSize", (PyCFunction) _wrap_NativeFontInfo_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21660          { (char *)"NativeFontInfo_SetStyle", (PyCFunction) _wrap_NativeFontInfo_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21661          { (char *)"NativeFontInfo_SetWeight", (PyCFunction) _wrap_NativeFontInfo_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21662          { (char *)"NativeFontInfo_SetUnderlined", (PyCFunction) _wrap_NativeFontInfo_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21663          { (char *)"NativeFontInfo_SetFaceName", (PyCFunction) _wrap_NativeFontInfo_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21664          { (char *)"NativeFontInfo_SetFamily", (PyCFunction) _wrap_NativeFontInfo_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21665          { (char *)"NativeFontInfo_SetEncoding", (PyCFunction) _wrap_NativeFontInfo_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21666          { (char *)"NativeFontInfo_FromString", (PyCFunction) _wrap_NativeFontInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
21667          { (char *)"NativeFontInfo_ToString", (PyCFunction) _wrap_NativeFontInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
21668          { (char *)"NativeFontInfo___str__", (PyCFunction) _wrap_NativeFontInfo___str__, METH_VARARGS | METH_KEYWORDS, NULL},
21669          { (char *)"NativeFontInfo_FromUserString", (PyCFunction) _wrap_NativeFontInfo_FromUserString, METH_VARARGS | METH_KEYWORDS, NULL},
21670          { (char *)"NativeFontInfo_ToUserString", (PyCFunction) _wrap_NativeFontInfo_ToUserString, METH_VARARGS | METH_KEYWORDS, NULL},
21671          { (char *)"NativeFontInfo_swigregister", NativeFontInfo_swigregister, METH_VARARGS, NULL},
21672          { (char *)"NativeEncodingInfo_facename_set", (PyCFunction) _wrap_NativeEncodingInfo_facename_set, METH_VARARGS | METH_KEYWORDS, NULL},
21673          { (char *)"NativeEncodingInfo_facename_get", (PyCFunction) _wrap_NativeEncodingInfo_facename_get, METH_VARARGS | METH_KEYWORDS, NULL},
21674          { (char *)"NativeEncodingInfo_encoding_set", (PyCFunction) _wrap_NativeEncodingInfo_encoding_set, METH_VARARGS | METH_KEYWORDS, NULL},
21675          { (char *)"NativeEncodingInfo_encoding_get", (PyCFunction) _wrap_NativeEncodingInfo_encoding_get, METH_VARARGS | METH_KEYWORDS, NULL},
21676          { (char *)"new_NativeEncodingInfo", (PyCFunction) _wrap_new_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21677          { (char *)"delete_NativeEncodingInfo", (PyCFunction) _wrap_delete_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21678          { (char *)"NativeEncodingInfo_FromString", (PyCFunction) _wrap_NativeEncodingInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
21679          { (char *)"NativeEncodingInfo_ToString", (PyCFunction) _wrap_NativeEncodingInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
21680          { (char *)"NativeEncodingInfo_swigregister", NativeEncodingInfo_swigregister, METH_VARARGS, NULL},
21681          { (char *)"GetNativeFontEncoding", (PyCFunction) _wrap_GetNativeFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21682          { (char *)"TestFontEncoding", (PyCFunction) _wrap_TestFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21683          { (char *)"new_FontMapper", (PyCFunction) _wrap_new_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
21684          { (char *)"delete_FontMapper", (PyCFunction) _wrap_delete_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
21685          { (char *)"FontMapper_Get", (PyCFunction) _wrap_FontMapper_Get, METH_VARARGS | METH_KEYWORDS, NULL},
21686          { (char *)"FontMapper_Set", (PyCFunction) _wrap_FontMapper_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21687          { (char *)"FontMapper_CharsetToEncoding", (PyCFunction) _wrap_FontMapper_CharsetToEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21688          { (char *)"FontMapper_GetSupportedEncodingsCount", (PyCFunction) _wrap_FontMapper_GetSupportedEncodingsCount, METH_VARARGS | METH_KEYWORDS, NULL},
21689          { (char *)"FontMapper_GetEncoding", (PyCFunction) _wrap_FontMapper_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21690          { (char *)"FontMapper_GetEncodingName", (PyCFunction) _wrap_FontMapper_GetEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
21691          { (char *)"FontMapper_GetEncodingDescription", (PyCFunction) _wrap_FontMapper_GetEncodingDescription, METH_VARARGS | METH_KEYWORDS, NULL},
21692          { (char *)"FontMapper_GetEncodingFromName", (PyCFunction) _wrap_FontMapper_GetEncodingFromName, METH_VARARGS | METH_KEYWORDS, NULL},
21693          { (char *)"FontMapper_SetConfig", (PyCFunction) _wrap_FontMapper_SetConfig, METH_VARARGS | METH_KEYWORDS, NULL},
21694          { (char *)"FontMapper_SetConfigPath", (PyCFunction) _wrap_FontMapper_SetConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
21695          { (char *)"FontMapper_GetDefaultConfigPath", (PyCFunction) _wrap_FontMapper_GetDefaultConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
21696          { (char *)"FontMapper_GetAltForEncoding", (PyCFunction) _wrap_FontMapper_GetAltForEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21697          { (char *)"FontMapper_IsEncodingAvailable", (PyCFunction) _wrap_FontMapper_IsEncodingAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
21698          { (char *)"FontMapper_SetDialogParent", (PyCFunction) _wrap_FontMapper_SetDialogParent, METH_VARARGS | METH_KEYWORDS, NULL},
21699          { (char *)"FontMapper_SetDialogTitle", (PyCFunction) _wrap_FontMapper_SetDialogTitle, METH_VARARGS | METH_KEYWORDS, NULL},
21700          { (char *)"FontMapper_swigregister", FontMapper_swigregister, METH_VARARGS, NULL},
21701          { (char *)"new_Font", (PyCFunction) _wrap_new_Font, METH_VARARGS | METH_KEYWORDS, NULL},
21702          { (char *)"delete_Font", (PyCFunction) _wrap_delete_Font, METH_VARARGS | METH_KEYWORDS, NULL},
21703          { (char *)"new_FontFromNativeInfo", (PyCFunction) _wrap_new_FontFromNativeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21704          { (char *)"new_FontFromNativeInfoString", (PyCFunction) _wrap_new_FontFromNativeInfoString, METH_VARARGS | METH_KEYWORDS, NULL},
21705          { (char *)"new_Font2", (PyCFunction) _wrap_new_Font2, METH_VARARGS | METH_KEYWORDS, NULL},
21706          { (char *)"new_FontFromPixelSize", (PyCFunction) _wrap_new_FontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21707          { (char *)"Font_Ok", (PyCFunction) _wrap_Font_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21708          { (char *)"Font___eq__", (PyCFunction) _wrap_Font___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21709          { (char *)"Font___ne__", (PyCFunction) _wrap_Font___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21710          { (char *)"Font_GetPointSize", (PyCFunction) _wrap_Font_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21711          { (char *)"Font_GetPixelSize", (PyCFunction) _wrap_Font_GetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21712          { (char *)"Font_IsUsingSizeInPixels", (PyCFunction) _wrap_Font_IsUsingSizeInPixels, METH_VARARGS | METH_KEYWORDS, NULL},
21713          { (char *)"Font_GetFamily", (PyCFunction) _wrap_Font_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21714          { (char *)"Font_GetStyle", (PyCFunction) _wrap_Font_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21715          { (char *)"Font_GetWeight", (PyCFunction) _wrap_Font_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21716          { (char *)"Font_GetUnderlined", (PyCFunction) _wrap_Font_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21717          { (char *)"Font_GetFaceName", (PyCFunction) _wrap_Font_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21718          { (char *)"Font_GetEncoding", (PyCFunction) _wrap_Font_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21719          { (char *)"Font_GetNativeFontInfo", (PyCFunction) _wrap_Font_GetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21720          { (char *)"Font_IsFixedWidth", (PyCFunction) _wrap_Font_IsFixedWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21721          { (char *)"Font_GetNativeFontInfoDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoDesc, METH_VARARGS | METH_KEYWORDS, NULL},
21722          { (char *)"Font_GetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
21723          { (char *)"Font_SetPointSize", (PyCFunction) _wrap_Font_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21724          { (char *)"Font_SetPixelSize", (PyCFunction) _wrap_Font_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21725          { (char *)"Font_SetFamily", (PyCFunction) _wrap_Font_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21726          { (char *)"Font_SetStyle", (PyCFunction) _wrap_Font_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21727          { (char *)"Font_SetWeight", (PyCFunction) _wrap_Font_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21728          { (char *)"Font_SetFaceName", (PyCFunction) _wrap_Font_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21729          { (char *)"Font_SetUnderlined", (PyCFunction) _wrap_Font_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21730          { (char *)"Font_SetEncoding", (PyCFunction) _wrap_Font_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21731          { (char *)"Font_SetNativeFontInfo", (PyCFunction) _wrap_Font_SetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21732          { (char *)"Font_SetNativeFontInfoFromString", (PyCFunction) _wrap_Font_SetNativeFontInfoFromString, METH_VARARGS | METH_KEYWORDS, NULL},
21733          { (char *)"Font_SetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_SetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
21734          { (char *)"Font_GetFamilyString", (PyCFunction) _wrap_Font_GetFamilyString, METH_VARARGS | METH_KEYWORDS, NULL},
21735          { (char *)"Font_GetStyleString", (PyCFunction) _wrap_Font_GetStyleString, METH_VARARGS | METH_KEYWORDS, NULL},
21736          { (char *)"Font_GetWeightString", (PyCFunction) _wrap_Font_GetWeightString, METH_VARARGS | METH_KEYWORDS, NULL},
21737          { (char *)"Font_SetNoAntiAliasing", (PyCFunction) _wrap_Font_SetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
21738          { (char *)"Font_GetNoAntiAliasing", (PyCFunction) _wrap_Font_GetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
21739          { (char *)"Font_GetDefaultEncoding", (PyCFunction) _wrap_Font_GetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21740          { (char *)"Font_SetDefaultEncoding", (PyCFunction) _wrap_Font_SetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21741          { (char *)"Font_swigregister", Font_swigregister, METH_VARARGS, NULL},
21742          { (char *)"new_FontEnumerator", (PyCFunction) _wrap_new_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
21743          { (char *)"delete_FontEnumerator", (PyCFunction) _wrap_delete_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
21744          { (char *)"FontEnumerator__setCallbackInfo", (PyCFunction) _wrap_FontEnumerator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21745          { (char *)"FontEnumerator_EnumerateFacenames", (PyCFunction) _wrap_FontEnumerator_EnumerateFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
21746          { (char *)"FontEnumerator_EnumerateEncodings", (PyCFunction) _wrap_FontEnumerator_EnumerateEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
21747          { (char *)"FontEnumerator_GetEncodings", (PyCFunction) _wrap_FontEnumerator_GetEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
21748          { (char *)"FontEnumerator_GetFacenames", (PyCFunction) _wrap_FontEnumerator_GetFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
21749          { (char *)"FontEnumerator_swigregister", FontEnumerator_swigregister, METH_VARARGS, NULL},
21750          { (char *)"LanguageInfo_Language_set", (PyCFunction) _wrap_LanguageInfo_Language_set, METH_VARARGS | METH_KEYWORDS, NULL},
21751          { (char *)"LanguageInfo_Language_get", (PyCFunction) _wrap_LanguageInfo_Language_get, METH_VARARGS | METH_KEYWORDS, NULL},
21752          { (char *)"LanguageInfo_CanonicalName_set", (PyCFunction) _wrap_LanguageInfo_CanonicalName_set, METH_VARARGS | METH_KEYWORDS, NULL},
21753          { (char *)"LanguageInfo_CanonicalName_get", (PyCFunction) _wrap_LanguageInfo_CanonicalName_get, METH_VARARGS | METH_KEYWORDS, NULL},
21754          { (char *)"LanguageInfo_Description_set", (PyCFunction) _wrap_LanguageInfo_Description_set, METH_VARARGS | METH_KEYWORDS, NULL},
21755          { (char *)"LanguageInfo_Description_get", (PyCFunction) _wrap_LanguageInfo_Description_get, METH_VARARGS | METH_KEYWORDS, NULL},
21756          { (char *)"LanguageInfo_swigregister", LanguageInfo_swigregister, METH_VARARGS, NULL},
21757          { (char *)"new_Locale", (PyCFunction) _wrap_new_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
21758          { (char *)"delete_Locale", (PyCFunction) _wrap_delete_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
21759          { (char *)"Locale_Init1", (PyCFunction) _wrap_Locale_Init1, METH_VARARGS | METH_KEYWORDS, NULL},
21760          { (char *)"Locale_Init2", (PyCFunction) _wrap_Locale_Init2, METH_VARARGS | METH_KEYWORDS, NULL},
21761          { (char *)"Locale_GetSystemLanguage", (PyCFunction) _wrap_Locale_GetSystemLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
21762          { (char *)"Locale_GetSystemEncoding", (PyCFunction) _wrap_Locale_GetSystemEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21763          { (char *)"Locale_GetSystemEncodingName", (PyCFunction) _wrap_Locale_GetSystemEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
21764          { (char *)"Locale_IsOk", (PyCFunction) _wrap_Locale_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
21765          { (char *)"Locale_GetLocale", (PyCFunction) _wrap_Locale_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
21766          { (char *)"Locale_GetLanguage", (PyCFunction) _wrap_Locale_GetLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
21767          { (char *)"Locale_GetSysName", (PyCFunction) _wrap_Locale_GetSysName, METH_VARARGS | METH_KEYWORDS, NULL},
21768          { (char *)"Locale_GetCanonicalName", (PyCFunction) _wrap_Locale_GetCanonicalName, METH_VARARGS | METH_KEYWORDS, NULL},
21769          { (char *)"Locale_AddCatalogLookupPathPrefix", (PyCFunction) _wrap_Locale_AddCatalogLookupPathPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
21770          { (char *)"Locale_AddCatalog", (PyCFunction) _wrap_Locale_AddCatalog, METH_VARARGS | METH_KEYWORDS, NULL},
21771          { (char *)"Locale_IsLoaded", (PyCFunction) _wrap_Locale_IsLoaded, METH_VARARGS | METH_KEYWORDS, NULL},
21772          { (char *)"Locale_GetLanguageInfo", (PyCFunction) _wrap_Locale_GetLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21773          { (char *)"Locale_GetLanguageName", (PyCFunction) _wrap_Locale_GetLanguageName, METH_VARARGS | METH_KEYWORDS, NULL},
21774          { (char *)"Locale_FindLanguageInfo", (PyCFunction) _wrap_Locale_FindLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21775          { (char *)"Locale_AddLanguage", (PyCFunction) _wrap_Locale_AddLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
21776          { (char *)"Locale_GetString", (PyCFunction) _wrap_Locale_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
21777          { (char *)"Locale_GetName", (PyCFunction) _wrap_Locale_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
21778          { (char *)"Locale_swigregister", Locale_swigregister, METH_VARARGS, NULL},
21779          { (char *)"GetLocale", (PyCFunction) _wrap_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
21780          { (char *)"GetTranslation", _wrap_GetTranslation, METH_VARARGS, NULL},
21781          { (char *)"new_EncodingConverter", (PyCFunction) _wrap_new_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
21782          { (char *)"delete_EncodingConverter", (PyCFunction) _wrap_delete_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
21783          { (char *)"EncodingConverter_Init", (PyCFunction) _wrap_EncodingConverter_Init, METH_VARARGS | METH_KEYWORDS, NULL},
21784          { (char *)"EncodingConverter_Convert", (PyCFunction) _wrap_EncodingConverter_Convert, METH_VARARGS | METH_KEYWORDS, NULL},
21785          { (char *)"EncodingConverter_GetPlatformEquivalents", (PyCFunction) _wrap_EncodingConverter_GetPlatformEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
21786          { (char *)"EncodingConverter_GetAllEquivalents", (PyCFunction) _wrap_EncodingConverter_GetAllEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
21787          { (char *)"EncodingConverter_CanConvert", (PyCFunction) _wrap_EncodingConverter_CanConvert, METH_VARARGS | METH_KEYWORDS, NULL},
21788          { (char *)"EncodingConverter_swigregister", EncodingConverter_swigregister, METH_VARARGS, NULL},
21789          { (char *)"delete_DC", (PyCFunction) _wrap_delete_DC, METH_VARARGS | METH_KEYWORDS, NULL},
21790          { (char *)"DC_BeginDrawing", (PyCFunction) _wrap_DC_BeginDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
21791          { (char *)"DC_EndDrawing", (PyCFunction) _wrap_DC_EndDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
21792          { (char *)"DC_FloodFill", (PyCFunction) _wrap_DC_FloodFill, METH_VARARGS | METH_KEYWORDS, NULL},
21793          { (char *)"DC_FloodFillPoint", (PyCFunction) _wrap_DC_FloodFillPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21794          { (char *)"DC_GetPixel", (PyCFunction) _wrap_DC_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
21795          { (char *)"DC_GetPixelPoint", (PyCFunction) _wrap_DC_GetPixelPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21796          { (char *)"DC_DrawLine", (PyCFunction) _wrap_DC_DrawLine, METH_VARARGS | METH_KEYWORDS, NULL},
21797          { (char *)"DC_DrawLinePoint", (PyCFunction) _wrap_DC_DrawLinePoint, METH_VARARGS | METH_KEYWORDS, NULL},
21798          { (char *)"DC_CrossHair", (PyCFunction) _wrap_DC_CrossHair, METH_VARARGS | METH_KEYWORDS, NULL},
21799          { (char *)"DC_CrossHairPoint", (PyCFunction) _wrap_DC_CrossHairPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21800          { (char *)"DC_DrawArc", (PyCFunction) _wrap_DC_DrawArc, METH_VARARGS | METH_KEYWORDS, NULL},
21801          { (char *)"DC_DrawArcPoint", (PyCFunction) _wrap_DC_DrawArcPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21802          { (char *)"DC_DrawCheckMark", (PyCFunction) _wrap_DC_DrawCheckMark, METH_VARARGS | METH_KEYWORDS, NULL},
21803          { (char *)"DC_DrawCheckMarkRect", (PyCFunction) _wrap_DC_DrawCheckMarkRect, METH_VARARGS | METH_KEYWORDS, NULL},
21804          { (char *)"DC_DrawEllipticArc", (PyCFunction) _wrap_DC_DrawEllipticArc, METH_VARARGS | METH_KEYWORDS, NULL},
21805          { (char *)"DC_DrawEllipticArcPointSize", (PyCFunction) _wrap_DC_DrawEllipticArcPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21806          { (char *)"DC_DrawPoint", (PyCFunction) _wrap_DC_DrawPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21807          { (char *)"DC_DrawPointPoint", (PyCFunction) _wrap_DC_DrawPointPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21808          { (char *)"DC_DrawRectangle", (PyCFunction) _wrap_DC_DrawRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
21809          { (char *)"DC_DrawRectangleRect", (PyCFunction) _wrap_DC_DrawRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
21810          { (char *)"DC_DrawRectanglePointSize", (PyCFunction) _wrap_DC_DrawRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21811          { (char *)"DC_DrawRoundedRectangle", (PyCFunction) _wrap_DC_DrawRoundedRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
21812          { (char *)"DC_DrawRoundedRectangleRect", (PyCFunction) _wrap_DC_DrawRoundedRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
21813          { (char *)"DC_DrawRoundedRectanglePointSize", (PyCFunction) _wrap_DC_DrawRoundedRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21814          { (char *)"DC_DrawCircle", (PyCFunction) _wrap_DC_DrawCircle, METH_VARARGS | METH_KEYWORDS, NULL},
21815          { (char *)"DC_DrawCirclePoint", (PyCFunction) _wrap_DC_DrawCirclePoint, METH_VARARGS | METH_KEYWORDS, NULL},
21816          { (char *)"DC_DrawEllipse", (PyCFunction) _wrap_DC_DrawEllipse, METH_VARARGS | METH_KEYWORDS, NULL},
21817          { (char *)"DC_DrawEllipseRect", (PyCFunction) _wrap_DC_DrawEllipseRect, METH_VARARGS | METH_KEYWORDS, NULL},
21818          { (char *)"DC_DrawEllipsePointSize", (PyCFunction) _wrap_DC_DrawEllipsePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21819          { (char *)"DC_DrawIcon", (PyCFunction) _wrap_DC_DrawIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21820          { (char *)"DC_DrawIconPoint", (PyCFunction) _wrap_DC_DrawIconPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21821          { (char *)"DC_DrawBitmap", (PyCFunction) _wrap_DC_DrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21822          { (char *)"DC_DrawBitmapPoint", (PyCFunction) _wrap_DC_DrawBitmapPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21823          { (char *)"DC_DrawText", (PyCFunction) _wrap_DC_DrawText, METH_VARARGS | METH_KEYWORDS, NULL},
21824          { (char *)"DC_DrawTextPoint", (PyCFunction) _wrap_DC_DrawTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21825          { (char *)"DC_DrawRotatedText", (PyCFunction) _wrap_DC_DrawRotatedText, METH_VARARGS | METH_KEYWORDS, NULL},
21826          { (char *)"DC_DrawRotatedTextPoint", (PyCFunction) _wrap_DC_DrawRotatedTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21827          { (char *)"DC_Blit", (PyCFunction) _wrap_DC_Blit, METH_VARARGS | METH_KEYWORDS, NULL},
21828          { (char *)"DC_BlitPointSize", (PyCFunction) _wrap_DC_BlitPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21829          { (char *)"DC_SetClippingRegion", (PyCFunction) _wrap_DC_SetClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21830          { (char *)"DC_SetClippingRegionPointSize", (PyCFunction) _wrap_DC_SetClippingRegionPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21831          { (char *)"DC_SetClippingRegionAsRegion", (PyCFunction) _wrap_DC_SetClippingRegionAsRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21832          { (char *)"DC_SetClippingRect", (PyCFunction) _wrap_DC_SetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
21833          { (char *)"DC_DrawLines", (PyCFunction) _wrap_DC_DrawLines, METH_VARARGS | METH_KEYWORDS, NULL},
21834          { (char *)"DC_DrawPolygon", (PyCFunction) _wrap_DC_DrawPolygon, METH_VARARGS | METH_KEYWORDS, NULL},
21835          { (char *)"DC_DrawLabel", (PyCFunction) _wrap_DC_DrawLabel, METH_VARARGS | METH_KEYWORDS, NULL},
21836          { (char *)"DC_DrawImageLabel", (PyCFunction) _wrap_DC_DrawImageLabel, METH_VARARGS | METH_KEYWORDS, NULL},
21837          { (char *)"DC_DrawSpline", (PyCFunction) _wrap_DC_DrawSpline, METH_VARARGS | METH_KEYWORDS, NULL},
21838          { (char *)"DC_Clear", (PyCFunction) _wrap_DC_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
21839          { (char *)"DC_StartDoc", (PyCFunction) _wrap_DC_StartDoc, METH_VARARGS | METH_KEYWORDS, NULL},
21840          { (char *)"DC_EndDoc", (PyCFunction) _wrap_DC_EndDoc, METH_VARARGS | METH_KEYWORDS, NULL},
21841          { (char *)"DC_StartPage", (PyCFunction) _wrap_DC_StartPage, METH_VARARGS | METH_KEYWORDS, NULL},
21842          { (char *)"DC_EndPage", (PyCFunction) _wrap_DC_EndPage, METH_VARARGS | METH_KEYWORDS, NULL},
21843          { (char *)"DC_SetFont", (PyCFunction) _wrap_DC_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
21844          { (char *)"DC_SetPen", (PyCFunction) _wrap_DC_SetPen, METH_VARARGS | METH_KEYWORDS, NULL},
21845          { (char *)"DC_SetBrush", (PyCFunction) _wrap_DC_SetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21846          { (char *)"DC_SetBackground", (PyCFunction) _wrap_DC_SetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21847          { (char *)"DC_SetBackgroundMode", (PyCFunction) _wrap_DC_SetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
21848          { (char *)"DC_SetPalette", (PyCFunction) _wrap_DC_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
21849          { (char *)"DC_DestroyClippingRegion", (PyCFunction) _wrap_DC_DestroyClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21850          { (char *)"DC_GetClippingBox", (PyCFunction) _wrap_DC_GetClippingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21851          { (char *)"DC_GetClippingRect", (PyCFunction) _wrap_DC_GetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
21852          { (char *)"DC_GetCharHeight", (PyCFunction) _wrap_DC_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21853          { (char *)"DC_GetCharWidth", (PyCFunction) _wrap_DC_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21854          { (char *)"DC_GetTextExtent", (PyCFunction) _wrap_DC_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21855          { (char *)"DC_GetFullTextExtent", (PyCFunction) _wrap_DC_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21856          { (char *)"DC_GetMultiLineTextExtent", (PyCFunction) _wrap_DC_GetMultiLineTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21857          { (char *)"DC_GetPartialTextExtents", (PyCFunction) _wrap_DC_GetPartialTextExtents, METH_VARARGS | METH_KEYWORDS, NULL},
21858          { (char *)"DC_GetSize", (PyCFunction) _wrap_DC_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21859          { (char *)"DC_GetSizeTuple", (PyCFunction) _wrap_DC_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21860          { (char *)"DC_GetSizeMM", (PyCFunction) _wrap_DC_GetSizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
21861          { (char *)"DC_GetSizeMMTuple", (PyCFunction) _wrap_DC_GetSizeMMTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21862          { (char *)"DC_DeviceToLogicalX", (PyCFunction) _wrap_DC_DeviceToLogicalX, METH_VARARGS | METH_KEYWORDS, NULL},
21863          { (char *)"DC_DeviceToLogicalY", (PyCFunction) _wrap_DC_DeviceToLogicalY, METH_VARARGS | METH_KEYWORDS, NULL},
21864          { (char *)"DC_DeviceToLogicalXRel", (PyCFunction) _wrap_DC_DeviceToLogicalXRel, METH_VARARGS | METH_KEYWORDS, NULL},
21865          { (char *)"DC_DeviceToLogicalYRel", (PyCFunction) _wrap_DC_DeviceToLogicalYRel, METH_VARARGS | METH_KEYWORDS, NULL},
21866          { (char *)"DC_LogicalToDeviceX", (PyCFunction) _wrap_DC_LogicalToDeviceX, METH_VARARGS | METH_KEYWORDS, NULL},
21867          { (char *)"DC_LogicalToDeviceY", (PyCFunction) _wrap_DC_LogicalToDeviceY, METH_VARARGS | METH_KEYWORDS, NULL},
21868          { (char *)"DC_LogicalToDeviceXRel", (PyCFunction) _wrap_DC_LogicalToDeviceXRel, METH_VARARGS | METH_KEYWORDS, NULL},
21869          { (char *)"DC_LogicalToDeviceYRel", (PyCFunction) _wrap_DC_LogicalToDeviceYRel, METH_VARARGS | METH_KEYWORDS, NULL},
21870          { (char *)"DC_CanDrawBitmap", (PyCFunction) _wrap_DC_CanDrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21871          { (char *)"DC_CanGetTextExtent", (PyCFunction) _wrap_DC_CanGetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21872          { (char *)"DC_GetDepth", (PyCFunction) _wrap_DC_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21873          { (char *)"DC_GetPPI", (PyCFunction) _wrap_DC_GetPPI, METH_VARARGS | METH_KEYWORDS, NULL},
21874          { (char *)"DC_Ok", (PyCFunction) _wrap_DC_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21875          { (char *)"DC_GetBackgroundMode", (PyCFunction) _wrap_DC_GetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
21876          { (char *)"DC_GetBackground", (PyCFunction) _wrap_DC_GetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21877          { (char *)"DC_GetBrush", (PyCFunction) _wrap_DC_GetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21878          { (char *)"DC_GetFont", (PyCFunction) _wrap_DC_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
21879          { (char *)"DC_GetPen", (PyCFunction) _wrap_DC_GetPen, METH_VARARGS | METH_KEYWORDS, NULL},
21880          { (char *)"DC_GetTextBackground", (PyCFunction) _wrap_DC_GetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21881          { (char *)"DC_GetTextForeground", (PyCFunction) _wrap_DC_GetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
21882          { (char *)"DC_SetTextForeground", (PyCFunction) _wrap_DC_SetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
21883          { (char *)"DC_SetTextBackground", (PyCFunction) _wrap_DC_SetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21884          { (char *)"DC_GetMapMode", (PyCFunction) _wrap_DC_GetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
21885          { (char *)"DC_SetMapMode", (PyCFunction) _wrap_DC_SetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
21886          { (char *)"DC_GetUserScale", (PyCFunction) _wrap_DC_GetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
21887          { (char *)"DC_SetUserScale", (PyCFunction) _wrap_DC_SetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
21888          { (char *)"DC_GetLogicalScale", (PyCFunction) _wrap_DC_GetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
21889          { (char *)"DC_SetLogicalScale", (PyCFunction) _wrap_DC_SetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
21890          { (char *)"DC_GetLogicalOrigin", (PyCFunction) _wrap_DC_GetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21891          { (char *)"DC_GetLogicalOriginTuple", (PyCFunction) _wrap_DC_GetLogicalOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21892          { (char *)"DC_SetLogicalOrigin", (PyCFunction) _wrap_DC_SetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21893          { (char *)"DC_SetLogicalOriginPoint", (PyCFunction) _wrap_DC_SetLogicalOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21894          { (char *)"DC_GetDeviceOrigin", (PyCFunction) _wrap_DC_GetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21895          { (char *)"DC_GetDeviceOriginTuple", (PyCFunction) _wrap_DC_GetDeviceOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21896          { (char *)"DC_SetDeviceOrigin", (PyCFunction) _wrap_DC_SetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21897          { (char *)"DC_SetDeviceOriginPoint", (PyCFunction) _wrap_DC_SetDeviceOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21898          { (char *)"DC_SetAxisOrientation", (PyCFunction) _wrap_DC_SetAxisOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
21899          { (char *)"DC_GetLogicalFunction", (PyCFunction) _wrap_DC_GetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
21900          { (char *)"DC_SetLogicalFunction", (PyCFunction) _wrap_DC_SetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
21901          { (char *)"DC_ComputeScaleAndOrigin", (PyCFunction) _wrap_DC_ComputeScaleAndOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21902          { (char *)"DC_CalcBoundingBox", (PyCFunction) _wrap_DC_CalcBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21903          { (char *)"DC_CalcBoundingBoxPoint", (PyCFunction) _wrap_DC_CalcBoundingBoxPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21904          { (char *)"DC_ResetBoundingBox", (PyCFunction) _wrap_DC_ResetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21905          { (char *)"DC_MinX", (PyCFunction) _wrap_DC_MinX, METH_VARARGS | METH_KEYWORDS, NULL},
21906          { (char *)"DC_MaxX", (PyCFunction) _wrap_DC_MaxX, METH_VARARGS | METH_KEYWORDS, NULL},
21907          { (char *)"DC_MinY", (PyCFunction) _wrap_DC_MinY, METH_VARARGS | METH_KEYWORDS, NULL},
21908          { (char *)"DC_MaxY", (PyCFunction) _wrap_DC_MaxY, METH_VARARGS | METH_KEYWORDS, NULL},
21909          { (char *)"DC_GetBoundingBox", (PyCFunction) _wrap_DC_GetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21910          { (char *)"DC_GetHDC", (PyCFunction) _wrap_DC_GetHDC, METH_VARARGS | METH_KEYWORDS, NULL},
21911          { (char *)"DC__DrawPointList", (PyCFunction) _wrap_DC__DrawPointList, METH_VARARGS | METH_KEYWORDS, NULL},
21912          { (char *)"DC__DrawLineList", (PyCFunction) _wrap_DC__DrawLineList, METH_VARARGS | METH_KEYWORDS, NULL},
21913          { (char *)"DC__DrawRectangleList", (PyCFunction) _wrap_DC__DrawRectangleList, METH_VARARGS | METH_KEYWORDS, NULL},
21914          { (char *)"DC__DrawEllipseList", (PyCFunction) _wrap_DC__DrawEllipseList, METH_VARARGS | METH_KEYWORDS, NULL},
21915          { (char *)"DC__DrawPolygonList", (PyCFunction) _wrap_DC__DrawPolygonList, METH_VARARGS | METH_KEYWORDS, NULL},
21916          { (char *)"DC__DrawTextList", (PyCFunction) _wrap_DC__DrawTextList, METH_VARARGS | METH_KEYWORDS, NULL},
21917          { (char *)"DC_swigregister", DC_swigregister, METH_VARARGS, NULL},
21918          { (char *)"new_MemoryDC", (PyCFunction) _wrap_new_MemoryDC, METH_VARARGS | METH_KEYWORDS, NULL},
21919          { (char *)"new_MemoryDCFromDC", (PyCFunction) _wrap_new_MemoryDCFromDC, METH_VARARGS | METH_KEYWORDS, NULL},
21920          { (char *)"MemoryDC_SelectObject", (PyCFunction) _wrap_MemoryDC_SelectObject, METH_VARARGS | METH_KEYWORDS, NULL},
21921          { (char *)"MemoryDC_swigregister", MemoryDC_swigregister, METH_VARARGS, NULL},
21922          { (char *)"new_BufferedDC", _wrap_new_BufferedDC, METH_VARARGS, NULL},
21923          { (char *)"delete_BufferedDC", (PyCFunction) _wrap_delete_BufferedDC, METH_VARARGS | METH_KEYWORDS, NULL},
21924          { (char *)"BufferedDC_UnMask", (PyCFunction) _wrap_BufferedDC_UnMask, METH_VARARGS | METH_KEYWORDS, NULL},
21925          { (char *)"BufferedDC_swigregister", BufferedDC_swigregister, METH_VARARGS, NULL},
21926          { (char *)"new_BufferedPaintDC", (PyCFunction) _wrap_new_BufferedPaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
21927          { (char *)"BufferedPaintDC_swigregister", BufferedPaintDC_swigregister, METH_VARARGS, NULL},
21928          { (char *)"new_ScreenDC", (PyCFunction) _wrap_new_ScreenDC, METH_VARARGS | METH_KEYWORDS, NULL},
21929          { (char *)"ScreenDC_StartDrawingOnTopWin", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTopWin, METH_VARARGS | METH_KEYWORDS, NULL},
21930          { (char *)"ScreenDC_StartDrawingOnTop", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
21931          { (char *)"ScreenDC_EndDrawingOnTop", (PyCFunction) _wrap_ScreenDC_EndDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
21932          { (char *)"ScreenDC_swigregister", ScreenDC_swigregister, METH_VARARGS, NULL},
21933          { (char *)"new_ClientDC", (PyCFunction) _wrap_new_ClientDC, METH_VARARGS | METH_KEYWORDS, NULL},
21934          { (char *)"ClientDC_swigregister", ClientDC_swigregister, METH_VARARGS, NULL},
21935          { (char *)"new_PaintDC", (PyCFunction) _wrap_new_PaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
21936          { (char *)"PaintDC_swigregister", PaintDC_swigregister, METH_VARARGS, NULL},
21937          { (char *)"new_WindowDC", (PyCFunction) _wrap_new_WindowDC, METH_VARARGS | METH_KEYWORDS, NULL},
21938          { (char *)"WindowDC_swigregister", WindowDC_swigregister, METH_VARARGS, NULL},
21939          { (char *)"new_MirrorDC", (PyCFunction) _wrap_new_MirrorDC, METH_VARARGS | METH_KEYWORDS, NULL},
21940          { (char *)"MirrorDC_swigregister", MirrorDC_swigregister, METH_VARARGS, NULL},
21941          { (char *)"new_PostScriptDC", (PyCFunction) _wrap_new_PostScriptDC, METH_VARARGS | METH_KEYWORDS, NULL},
21942          { (char *)"PostScriptDC_GetPrintData", (PyCFunction) _wrap_PostScriptDC_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
21943          { (char *)"PostScriptDC_SetPrintData", (PyCFunction) _wrap_PostScriptDC_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
21944          { (char *)"PostScriptDC_SetResolution", (PyCFunction) _wrap_PostScriptDC_SetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
21945          { (char *)"PostScriptDC_GetResolution", (PyCFunction) _wrap_PostScriptDC_GetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
21946          { (char *)"PostScriptDC_swigregister", PostScriptDC_swigregister, METH_VARARGS, NULL},
21947          { (char *)"new_MetaFile", (PyCFunction) _wrap_new_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
21948          { (char *)"delete_MetaFile", (PyCFunction) _wrap_delete_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
21949          { (char *)"MetaFile_Ok", (PyCFunction) _wrap_MetaFile_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21950          { (char *)"MetaFile_SetClipboard", (PyCFunction) _wrap_MetaFile_SetClipboard, METH_VARARGS | METH_KEYWORDS, NULL},
21951          { (char *)"MetaFile_GetSize", (PyCFunction) _wrap_MetaFile_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21952          { (char *)"MetaFile_GetWidth", (PyCFunction) _wrap_MetaFile_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21953          { (char *)"MetaFile_GetHeight", (PyCFunction) _wrap_MetaFile_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21954          { (char *)"MetaFile_GetFileName", (PyCFunction) _wrap_MetaFile_GetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
21955          { (char *)"MetaFile_swigregister", MetaFile_swigregister, METH_VARARGS, NULL},
21956          { (char *)"new_MetaFileDC", (PyCFunction) _wrap_new_MetaFileDC, METH_VARARGS | METH_KEYWORDS, NULL},
21957          { (char *)"MetaFileDC_Close", (PyCFunction) _wrap_MetaFileDC_Close, METH_VARARGS | METH_KEYWORDS, NULL},
21958          { (char *)"MetaFileDC_swigregister", MetaFileDC_swigregister, METH_VARARGS, NULL},
21959          { (char *)"new_PrinterDC", (PyCFunction) _wrap_new_PrinterDC, METH_VARARGS | METH_KEYWORDS, NULL},
21960          { (char *)"PrinterDC_swigregister", PrinterDC_swigregister, METH_VARARGS, NULL},
21961          { (char *)"new_ImageList", (PyCFunction) _wrap_new_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
21962          { (char *)"delete_ImageList", (PyCFunction) _wrap_delete_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
21963          { (char *)"ImageList_Add", (PyCFunction) _wrap_ImageList_Add, METH_VARARGS | METH_KEYWORDS, NULL},
21964          { (char *)"ImageList_AddWithColourMask", (PyCFunction) _wrap_ImageList_AddWithColourMask, METH_VARARGS | METH_KEYWORDS, NULL},
21965          { (char *)"ImageList_AddIcon", (PyCFunction) _wrap_ImageList_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21966          { (char *)"ImageList_GetBitmap", (PyCFunction) _wrap_ImageList_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21967          { (char *)"ImageList_GetIcon", (PyCFunction) _wrap_ImageList_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21968          { (char *)"ImageList_Replace", (PyCFunction) _wrap_ImageList_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
21969          { (char *)"ImageList_Draw", (PyCFunction) _wrap_ImageList_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
21970          { (char *)"ImageList_GetImageCount", (PyCFunction) _wrap_ImageList_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
21971          { (char *)"ImageList_Remove", (PyCFunction) _wrap_ImageList_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
21972          { (char *)"ImageList_RemoveAll", (PyCFunction) _wrap_ImageList_RemoveAll, METH_VARARGS | METH_KEYWORDS, NULL},
21973          { (char *)"ImageList_GetSize", (PyCFunction) _wrap_ImageList_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21974          { (char *)"ImageList_swigregister", ImageList_swigregister, METH_VARARGS, NULL},
21975          { (char *)"PenList_AddPen", (PyCFunction) _wrap_PenList_AddPen, METH_VARARGS | METH_KEYWORDS, NULL},
21976          { (char *)"PenList_FindOrCreatePen", (PyCFunction) _wrap_PenList_FindOrCreatePen, METH_VARARGS | METH_KEYWORDS, NULL},
21977          { (char *)"PenList_RemovePen", (PyCFunction) _wrap_PenList_RemovePen, METH_VARARGS | METH_KEYWORDS, NULL},
21978          { (char *)"PenList_GetCount", (PyCFunction) _wrap_PenList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21979          { (char *)"PenList_swigregister", PenList_swigregister, METH_VARARGS, NULL},
21980          { (char *)"BrushList_AddBrush", (PyCFunction) _wrap_BrushList_AddBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21981          { (char *)"BrushList_FindOrCreateBrush", (PyCFunction) _wrap_BrushList_FindOrCreateBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21982          { (char *)"BrushList_RemoveBrush", (PyCFunction) _wrap_BrushList_RemoveBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21983          { (char *)"BrushList_GetCount", (PyCFunction) _wrap_BrushList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21984          { (char *)"BrushList_swigregister", BrushList_swigregister, METH_VARARGS, NULL},
21985          { (char *)"new_ColourDatabase", (PyCFunction) _wrap_new_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
21986          { (char *)"delete_ColourDatabase", (PyCFunction) _wrap_delete_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
21987          { (char *)"ColourDatabase_Find", (PyCFunction) _wrap_ColourDatabase_Find, METH_VARARGS | METH_KEYWORDS, NULL},
21988          { (char *)"ColourDatabase_FindName", (PyCFunction) _wrap_ColourDatabase_FindName, METH_VARARGS | METH_KEYWORDS, NULL},
21989          { (char *)"ColourDatabase_AddColour", (PyCFunction) _wrap_ColourDatabase_AddColour, METH_VARARGS | METH_KEYWORDS, NULL},
21990          { (char *)"ColourDatabase_Append", (PyCFunction) _wrap_ColourDatabase_Append, METH_VARARGS | METH_KEYWORDS, NULL},
21991          { (char *)"ColourDatabase_swigregister", ColourDatabase_swigregister, METH_VARARGS, NULL},
21992          { (char *)"FontList_AddFont", (PyCFunction) _wrap_FontList_AddFont, METH_VARARGS | METH_KEYWORDS, NULL},
21993          { (char *)"FontList_FindOrCreateFont", (PyCFunction) _wrap_FontList_FindOrCreateFont, METH_VARARGS | METH_KEYWORDS, NULL},
21994          { (char *)"FontList_RemoveFont", (PyCFunction) _wrap_FontList_RemoveFont, METH_VARARGS | METH_KEYWORDS, NULL},
21995          { (char *)"FontList_GetCount", (PyCFunction) _wrap_FontList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21996          { (char *)"FontList_swigregister", FontList_swigregister, METH_VARARGS, NULL},
21997          { (char *)"new_Effects", (PyCFunction) _wrap_new_Effects, METH_VARARGS | METH_KEYWORDS, NULL},
21998          { (char *)"Effects_GetHighlightColour", (PyCFunction) _wrap_Effects_GetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
21999          { (char *)"Effects_GetLightShadow", (PyCFunction) _wrap_Effects_GetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22000          { (char *)"Effects_GetFaceColour", (PyCFunction) _wrap_Effects_GetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
22001          { (char *)"Effects_GetMediumShadow", (PyCFunction) _wrap_Effects_GetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22002          { (char *)"Effects_GetDarkShadow", (PyCFunction) _wrap_Effects_GetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22003          { (char *)"Effects_SetHighlightColour", (PyCFunction) _wrap_Effects_SetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
22004          { (char *)"Effects_SetLightShadow", (PyCFunction) _wrap_Effects_SetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22005          { (char *)"Effects_SetFaceColour", (PyCFunction) _wrap_Effects_SetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
22006          { (char *)"Effects_SetMediumShadow", (PyCFunction) _wrap_Effects_SetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22007          { (char *)"Effects_SetDarkShadow", (PyCFunction) _wrap_Effects_SetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22008          { (char *)"Effects_Set", (PyCFunction) _wrap_Effects_Set, METH_VARARGS | METH_KEYWORDS, NULL},
22009          { (char *)"Effects_DrawSunkenEdge", (PyCFunction) _wrap_Effects_DrawSunkenEdge, METH_VARARGS | METH_KEYWORDS, NULL},
22010          { (char *)"Effects_TileBitmap", (PyCFunction) _wrap_Effects_TileBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22011          { (char *)"Effects_swigregister", Effects_swigregister, METH_VARARGS, NULL},
22012          { NULL, NULL, 0, NULL }
22013 };
22014
22015
22016 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
22017
22018 static void *_p_wxBufferedDCTo_p_wxMemoryDC(void *x) {
22019     return (void *)((wxMemoryDC *)  ((wxBufferedDC *) x));
22020 }
22021 static void *_p_wxBufferedPaintDCTo_p_wxMemoryDC(void *x) {
22022     return (void *)((wxMemoryDC *) (wxBufferedDC *) ((wxBufferedPaintDC *) x));
22023 }
22024 static void *_p_wxIconTo_p_wxGDIObject(void *x) {
22025     return (void *)((wxGDIObject *)  ((wxIcon *) x));
22026 }
22027 static void *_p_wxPaletteTo_p_wxGDIObject(void *x) {
22028     return (void *)((wxGDIObject *)  ((wxPalette *) x));
22029 }
22030 static void *_p_wxPenTo_p_wxGDIObject(void *x) {
22031     return (void *)((wxGDIObject *)  ((wxPen *) x));
22032 }
22033 static void *_p_wxFontTo_p_wxGDIObject(void *x) {
22034     return (void *)((wxGDIObject *)  ((wxFont *) x));
22035 }
22036 static void *_p_wxCursorTo_p_wxGDIObject(void *x) {
22037     return (void *)((wxGDIObject *)  ((wxCursor *) x));
22038 }
22039 static void *_p_wxBitmapTo_p_wxGDIObject(void *x) {
22040     return (void *)((wxGDIObject *)  ((wxBitmap *) x));
22041 }
22042 static void *_p_wxRegionTo_p_wxGDIObject(void *x) {
22043     return (void *)((wxGDIObject *)  ((wxRegion *) x));
22044 }
22045 static void *_p_wxBrushTo_p_wxGDIObject(void *x) {
22046     return (void *)((wxGDIObject *)  ((wxBrush *) x));
22047 }
22048 static void *_p_wxBufferedDCTo_p_wxDC(void *x) {
22049     return (void *)((wxDC *) (wxMemoryDC *) ((wxBufferedDC *) x));
22050 }
22051 static void *_p_wxScreenDCTo_p_wxDC(void *x) {
22052     return (void *)((wxDC *)  ((wxScreenDC *) x));
22053 }
22054 static void *_p_wxMirrorDCTo_p_wxDC(void *x) {
22055     return (void *)((wxDC *)  ((wxMirrorDC *) x));
22056 }
22057 static void *_p_wxMemoryDCTo_p_wxDC(void *x) {
22058     return (void *)((wxDC *)  ((wxMemoryDC *) x));
22059 }
22060 static void *_p_wxWindowDCTo_p_wxDC(void *x) {
22061     return (void *)((wxDC *)  ((wxWindowDC *) x));
22062 }
22063 static void *_p_wxMetaFileDCTo_p_wxDC(void *x) {
22064     return (void *)((wxDC *)  ((wxMetaFileDC *) x));
22065 }
22066 static void *_p_wxBufferedPaintDCTo_p_wxDC(void *x) {
22067     return (void *)((wxDC *) (wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
22068 }
22069 static void *_p_wxClientDCTo_p_wxDC(void *x) {
22070     return (void *)((wxDC *)  ((wxClientDC *) x));
22071 }
22072 static void *_p_wxPaintDCTo_p_wxDC(void *x) {
22073     return (void *)((wxDC *)  ((wxPaintDC *) x));
22074 }
22075 static void *_p_wxPostScriptDCTo_p_wxDC(void *x) {
22076     return (void *)((wxDC *)  ((wxPostScriptDC *) x));
22077 }
22078 static void *_p_wxPrinterDCTo_p_wxDC(void *x) {
22079     return (void *)((wxDC *)  ((wxPrinterDC *) x));
22080 }
22081 static void *_p_wxBufferedPaintDCTo_p_wxBufferedDC(void *x) {
22082     return (void *)((wxBufferedDC *)  ((wxBufferedPaintDC *) x));
22083 }
22084 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
22085     return (void *)((wxObject *)  ((wxLayoutConstraints *) x));
22086 }
22087 static void *_p_wxPenTo_p_wxObject(void *x) {
22088     return (void *)((wxObject *) (wxGDIObject *) ((wxPen *) x));
22089 }
22090 static void *_p_wxRegionIteratorTo_p_wxObject(void *x) {
22091     return (void *)((wxObject *)  ((wxRegionIterator *) x));
22092 }
22093 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
22094     return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
22095 }
22096 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
22097     return (void *)((wxObject *)  ((wxSizerItem *) x));
22098 }
22099 static void *_p_wxColourDatabaseTo_p_wxObject(void *x) {
22100     return (void *)((wxObject *)  ((wxColourDatabase *) x));
22101 }
22102 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
22103     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
22104 }
22105 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
22106     return (void *)((wxObject *)  ((wxIndividualLayoutConstraint *) x));
22107 }
22108 static void *_p_wxIconTo_p_wxObject(void *x) {
22109     return (void *)((wxObject *) (wxGDIObject *) ((wxIcon *) x));
22110 }
22111 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
22112     return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
22113 }
22114 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
22115     return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
22116 }
22117 static void *_p_wxSizerTo_p_wxObject(void *x) {
22118     return (void *)((wxObject *)  ((wxSizer *) x));
22119 }
22120 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
22121     return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
22122 }
22123 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
22124     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
22125 }
22126 static void *_p_wxPenListTo_p_wxObject(void *x) {
22127     return (void *)((wxObject *)  ((wxPenList *) x));
22128 }
22129 static void *_p_wxEventTo_p_wxObject(void *x) {
22130     return (void *)((wxObject *)  ((wxEvent *) x));
22131 }
22132 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
22133     return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
22134 }
22135 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
22136     return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
22137 }
22138 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
22139     return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
22140 }
22141 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
22142     return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
22143 }
22144 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
22145     return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
22146 }
22147 static void *_p_wxDCTo_p_wxObject(void *x) {
22148     return (void *)((wxObject *)  ((wxDC *) x));
22149 }
22150 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
22151     return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
22152 }
22153 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
22154     return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
22155 }
22156 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
22157     return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
22158 }
22159 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
22160     return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
22161 }
22162 static void *_p_wxControlTo_p_wxObject(void *x) {
22163     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
22164 }
22165 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
22166     return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
22167 }
22168 static void *_p_wxClientDCTo_p_wxObject(void *x) {
22169     return (void *)((wxObject *) (wxDC *) ((wxClientDC *) x));
22170 }
22171 static void *_p_wxFSFileTo_p_wxObject(void *x) {
22172     return (void *)((wxObject *)  ((wxFSFile *) x));
22173 }
22174 static void *_p_wxMemoryDCTo_p_wxObject(void *x) {
22175     return (void *)((wxObject *) (wxDC *) ((wxMemoryDC *) x));
22176 }
22177 static void *_p_wxRegionTo_p_wxObject(void *x) {
22178     return (void *)((wxObject *) (wxGDIObject *) ((wxRegion *) x));
22179 }
22180 static void *_p_wxPySizerTo_p_wxObject(void *x) {
22181     return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
22182 }
22183 static void *_p_wxWindowDCTo_p_wxObject(void *x) {
22184     return (void *)((wxObject *) (wxDC *) ((wxWindowDC *) x));
22185 }
22186 static void *_p_wxGDIObjectTo_p_wxObject(void *x) {
22187     return (void *)((wxObject *)  ((wxGDIObject *) x));
22188 }
22189 static void *_p_wxEffectsTo_p_wxObject(void *x) {
22190     return (void *)((wxObject *)  ((wxEffects *) x));
22191 }
22192 static void *_p_wxPyEventTo_p_wxObject(void *x) {
22193     return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
22194 }
22195 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
22196     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
22197 }
22198 static void *_p_wxPostScriptDCTo_p_wxObject(void *x) {
22199     return (void *)((wxObject *) (wxDC *) ((wxPostScriptDC *) x));
22200 }
22201 static void *_p_wxShowEventTo_p_wxObject(void *x) {
22202     return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
22203 }
22204 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
22205     return (void *)((wxObject *)  ((wxMenuItem *) x));
22206 }
22207 static void *_p_wxDateEventTo_p_wxObject(void *x) {
22208     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
22209 }
22210 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
22211     return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
22212 }
22213 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
22214     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
22215 }
22216 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
22217     return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
22218 }
22219 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
22220     return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
22221 }
22222 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
22223     return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
22224 }
22225 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
22226     return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
22227 }
22228 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
22229     return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
22230 }
22231 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
22232     return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
22233 }
22234 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
22235     return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
22236 }
22237 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
22238     return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
22239 }
22240 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
22241     return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
22242 }
22243 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
22244     return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
22245 }
22246 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
22247     return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
22248 }
22249 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
22250     return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
22251 }
22252 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
22253     return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
22254 }
22255 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
22256     return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
22257 }
22258 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
22259     return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
22260 }
22261 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
22262     return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
22263 }
22264 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
22265     return (void *)((wxObject *)  ((wxImageHandler *) x));
22266 }
22267 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
22268     return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
22269 }
22270 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
22271     return (void *)((wxObject *)  ((wxEvtHandler *) x));
22272 }
22273 static void *_p_wxBufferedPaintDCTo_p_wxObject(void *x) {
22274     return (void *)((wxObject *) (wxDC *)(wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
22275 }
22276 static void *_p_wxPaintDCTo_p_wxObject(void *x) {
22277     return (void *)((wxObject *) (wxDC *) ((wxPaintDC *) x));
22278 }
22279 static void *_p_wxPrinterDCTo_p_wxObject(void *x) {
22280     return (void *)((wxObject *) (wxDC *) ((wxPrinterDC *) x));
22281 }
22282 static void *_p_wxScreenDCTo_p_wxObject(void *x) {
22283     return (void *)((wxObject *) (wxDC *) ((wxScreenDC *) x));
22284 }
22285 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
22286     return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
22287 }
22288 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
22289     return (void *)((wxObject *)  ((wxAcceleratorTable *) x));
22290 }
22291 static void *_p_wxImageTo_p_wxObject(void *x) {
22292     return (void *)((wxObject *)  ((wxImage *) x));
22293 }
22294 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
22295     return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
22296 }
22297 static void *_p_wxPaletteTo_p_wxObject(void *x) {
22298     return (void *)((wxObject *) (wxGDIObject *) ((wxPalette *) x));
22299 }
22300 static void *_p_wxBufferedDCTo_p_wxObject(void *x) {
22301     return (void *)((wxObject *) (wxDC *)(wxMemoryDC *) ((wxBufferedDC *) x));
22302 }
22303 static void *_p_wxImageListTo_p_wxObject(void *x) {
22304     return (void *)((wxObject *)  ((wxImageList *) x));
22305 }
22306 static void *_p_wxCursorTo_p_wxObject(void *x) {
22307     return (void *)((wxObject *) (wxGDIObject *) ((wxCursor *) x));
22308 }
22309 static void *_p_wxEncodingConverterTo_p_wxObject(void *x) {
22310     return (void *)((wxObject *)  ((wxEncodingConverter *) x));
22311 }
22312 static void *_p_wxMirrorDCTo_p_wxObject(void *x) {
22313     return (void *)((wxObject *) (wxDC *) ((wxMirrorDC *) x));
22314 }
22315 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
22316     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
22317 }
22318 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
22319     return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
22320 }
22321 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
22322     return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
22323 }
22324 static void *_p_wxWindowTo_p_wxObject(void *x) {
22325     return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
22326 }
22327 static void *_p_wxMenuTo_p_wxObject(void *x) {
22328     return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
22329 }
22330 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
22331     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
22332 }
22333 static void *_p_wxMetaFileDCTo_p_wxObject(void *x) {
22334     return (void *)((wxObject *) (wxDC *) ((wxMetaFileDC *) x));
22335 }
22336 static void *_p_wxBrushListTo_p_wxObject(void *x) {
22337     return (void *)((wxObject *)  ((wxBrushList *) x));
22338 }
22339 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
22340     return (void *)((wxObject *)  ((wxFileSystem *) x));
22341 }
22342 static void *_p_wxBitmapTo_p_wxObject(void *x) {
22343     return (void *)((wxObject *) (wxGDIObject *) ((wxBitmap *) x));
22344 }
22345 static void *_p_wxMaskTo_p_wxObject(void *x) {
22346     return (void *)((wxObject *)  ((wxMask *) x));
22347 }
22348 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
22349     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
22350 }
22351 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
22352     return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
22353 }
22354 static void *_p_wxPyAppTo_p_wxObject(void *x) {
22355     return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
22356 }
22357 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
22358     return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
22359 }
22360 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
22361     return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
22362 }
22363 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
22364     return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
22365 }
22366 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
22367     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
22368 }
22369 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
22370     return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
22371 }
22372 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
22373     return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
22374 }
22375 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
22376     return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
22377 }
22378 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
22379     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
22380 }
22381 static void *_p_wxFontTo_p_wxObject(void *x) {
22382     return (void *)((wxObject *) (wxGDIObject *) ((wxFont *) x));
22383 }
22384 static void *_p_wxBrushTo_p_wxObject(void *x) {
22385     return (void *)((wxObject *) (wxGDIObject *) ((wxBrush *) x));
22386 }
22387 static void *_p_wxMetaFileTo_p_wxObject(void *x) {
22388     return (void *)((wxObject *)  ((wxMetaFile *) x));
22389 }
22390 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
22391     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
22392 }
22393 static void *_p_wxColourTo_p_wxObject(void *x) {
22394     return (void *)((wxObject *)  ((wxColour *) x));
22395 }
22396 static void *_p_wxFontListTo_p_wxObject(void *x) {
22397     return (void *)((wxObject *)  ((wxFontList *) x));
22398 }
22399 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
22400     return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
22401 }
22402 static void *_p_wxValidatorTo_p_wxObject(void *x) {
22403     return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
22404 }
22405 static void *_p_wxControlTo_p_wxWindow(void *x) {
22406     return (void *)((wxWindow *)  ((wxControl *) x));
22407 }
22408 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
22409     return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
22410 }
22411 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
22412     return (void *)((wxWindow *)  ((wxMenuBar *) x));
22413 }
22414 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}};
22415 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}};
22416 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}};
22417 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}};
22418 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}};
22419 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}};
22420 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}};
22421 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}};
22422 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}};
22423 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}};
22424 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}};
22425 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}};
22426 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}};
22427 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}};
22428 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}};
22429 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}};
22430 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}};
22431 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}};
22432 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}};
22433 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}};
22434 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}};
22435 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}};
22436 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}};
22437 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}};
22438 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}};
22439 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}};
22440 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}};
22441 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}};
22442 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}};
22443 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}};
22444 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}};
22445 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}};
22446 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}};
22447 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}};
22448 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}};
22449 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}};
22450 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}};
22451 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}};
22452 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}};
22453 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}};
22454 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}};
22455 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}};
22456 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}};
22457 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}};
22458 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}};
22459 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}};
22460 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}};
22461 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}};
22462 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}};
22463 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}};
22464 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}};
22465 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}};
22466 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}};
22467 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}};
22468 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}};
22469 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}};
22470 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}};
22471 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}};
22472 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}};
22473 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}};
22474 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}};
22475 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}};
22476
22477 static swig_type_info *swig_types_initial[] = {
22478 _swigt__p_wxPostScriptDC,
22479 _swigt__p_wxBrush,
22480 _swigt__p_wxColour,
22481 _swigt__p_wxDC,
22482 _swigt__p_wxMirrorDC,
22483 _swigt__p_form_ops_t,
22484 _swigt__p_wxDuplexMode,
22485 _swigt__p_wxPyFontEnumerator,
22486 _swigt__p_char,
22487 _swigt__p_wxIconLocation,
22488 _swigt__p_wxImage,
22489 _swigt__p_wxMetaFileDC,
22490 _swigt__p_wxMask,
22491 _swigt__p_wxSize,
22492 _swigt__p_wxFont,
22493 _swigt__p_wxWindow,
22494 _swigt__p_double,
22495 _swigt__p_wxMemoryDC,
22496 _swigt__p_wxFontMapper,
22497 _swigt__p_wxEffects,
22498 _swigt__p_wxNativeEncodingInfo,
22499 _swigt__p_wxPalette,
22500 _swigt__p_wxBitmap,
22501 _swigt__p_wxObject,
22502 _swigt__p_wxRegionIterator,
22503 _swigt__p_wxRect,
22504 _swigt__p_wxPaperSize,
22505 _swigt__p_wxString,
22506 _swigt__unsigned_int,
22507 _swigt__p_unsigned_int,
22508 _swigt__p_wxPrinterDC,
22509 _swigt__p_wxIconBundle,
22510 _swigt__p_wxPoint,
22511 _swigt__p_wxDash,
22512 _swigt__p_wxScreenDC,
22513 _swigt__p_wxCursor,
22514 _swigt__p_wxClientDC,
22515 _swigt__p_wxBufferedDC,
22516 _swigt__p_wxImageList,
22517 _swigt__p_unsigned_char,
22518 _swigt__p_wxGDIObject,
22519 _swigt__p_wxIcon,
22520 _swigt__p_wxLocale,
22521 _swigt__ptrdiff_t,
22522 _swigt__std__ptrdiff_t,
22523 _swigt__p_wxRegion,
22524 _swigt__p_wxConfigBase,
22525 _swigt__p_wxLanguageInfo,
22526 _swigt__p_wxWindowDC,
22527 _swigt__p_wxPrintData,
22528 _swigt__p_wxBrushList,
22529 _swigt__p_wxFontList,
22530 _swigt__p_wxPen,
22531 _swigt__p_wxBufferedPaintDC,
22532 _swigt__p_wxPaintDC,
22533 _swigt__p_wxPenList,
22534 _swigt__p_int,
22535 _swigt__p_wxMetaFile,
22536 _swigt__p_unsigned_long,
22537 _swigt__p_wxNativeFontInfo,
22538 _swigt__p_wxEncodingConverter,
22539 _swigt__p_wxColourDatabase,
22540 0
22541 };
22542
22543
22544 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
22545
22546 static swig_const_info swig_const_table[] = {
22547 {0, 0, 0, 0.0, 0, 0}};
22548
22549 #ifdef __cplusplus
22550 }
22551 #endif
22552
22553
22554 #ifdef __cplusplus
22555 extern "C" {
22556 #endif
22557
22558     /* Python-specific SWIG API */
22559 #define SWIG_newvarlink()                             SWIG_Python_newvarlink()
22560 #define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
22561 #define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
22562
22563     /* -----------------------------------------------------------------------------
22564      * global variable support code.
22565      * ----------------------------------------------------------------------------- */
22566
22567     typedef struct swig_globalvar {
22568         char       *name;                  /* Name of global variable */
22569         PyObject *(*get_attr)();           /* Return the current value */
22570         int       (*set_attr)(PyObject *); /* Set the value */
22571         struct swig_globalvar *next;
22572     } swig_globalvar;
22573
22574     typedef struct swig_varlinkobject {
22575         PyObject_HEAD
22576         swig_globalvar *vars;
22577     } swig_varlinkobject;
22578
22579     static PyObject *
22580     swig_varlink_repr(swig_varlinkobject *v) {
22581         v = v;
22582         return PyString_FromString("<Swig global variables>");
22583     }
22584
22585     static int
22586     swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
22587         swig_globalvar  *var;
22588         flags = flags;
22589         fprintf(fp,"Swig global variables { ");
22590         for (var = v->vars; var; var=var->next) {
22591             fprintf(fp,"%s", var->name);
22592             if (var->next) fprintf(fp,", ");
22593         }
22594         fprintf(fp," }\n");
22595         return 0;
22596     }
22597
22598     static PyObject *
22599     swig_varlink_getattr(swig_varlinkobject *v, char *n) {
22600         swig_globalvar *var = v->vars;
22601         while (var) {
22602             if (strcmp(var->name,n) == 0) {
22603                 return (*var->get_attr)();
22604             }
22605             var = var->next;
22606         }
22607         PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22608         return NULL;
22609     }
22610
22611     static int
22612     swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
22613         swig_globalvar *var = v->vars;
22614         while (var) {
22615             if (strcmp(var->name,n) == 0) {
22616                 return (*var->set_attr)(p);
22617             }
22618             var = var->next;
22619         }
22620         PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22621         return 1;
22622     }
22623
22624     static PyTypeObject varlinktype = {
22625         PyObject_HEAD_INIT(0)
22626         0,                                  /* Number of items in variable part (ob_size) */
22627         (char *)"swigvarlink",              /* Type name (tp_name) */
22628         sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
22629         0,                                  /* Itemsize (tp_itemsize) */
22630         0,                                  /* Deallocator (tp_dealloc) */
22631         (printfunc) swig_varlink_print,     /* Print (tp_print) */
22632         (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
22633         (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
22634         0,                                  /* tp_compare */
22635         (reprfunc) swig_varlink_repr,       /* tp_repr */
22636         0,                                  /* tp_as_number */
22637         0,                                  /* tp_as_sequence */
22638         0,                                  /* tp_as_mapping */
22639         0,                                  /* tp_hash */
22640         0,                                  /* tp_call */
22641         0,                                  /* tp_str */
22642         0,                                  /* tp_getattro */
22643         0,                                  /* tp_setattro */
22644         0,                                  /* tp_as_buffer */
22645         0,                                  /* tp_flags */
22646         0,                                  /* tp_doc */
22647 #if PY_VERSION_HEX >= 0x02000000
22648         0,                                  /* tp_traverse */
22649         0,                                  /* tp_clear */
22650 #endif
22651 #if PY_VERSION_HEX >= 0x02010000
22652         0,                                  /* tp_richcompare */
22653         0,                                  /* tp_weaklistoffset */
22654 #endif
22655 #if PY_VERSION_HEX >= 0x02020000
22656         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
22657 #endif
22658 #if PY_VERSION_HEX >= 0x02030000
22659         0,                                  /* tp_del */
22660 #endif
22661 #ifdef COUNT_ALLOCS
22662         0,0,0,0                             /* tp_alloc -> tp_next */
22663 #endif
22664     };
22665
22666     /* Create a variable linking object for use later */
22667     static PyObject *
22668     SWIG_Python_newvarlink(void) {
22669         swig_varlinkobject *result = 0;
22670         result = PyMem_NEW(swig_varlinkobject,1);
22671         varlinktype.ob_type = &PyType_Type;    /* Patch varlinktype into a PyType */
22672         result->ob_type = &varlinktype;
22673         result->vars = 0;
22674         result->ob_refcnt = 0;
22675         Py_XINCREF((PyObject *) result);
22676         return ((PyObject*) result);
22677     }
22678
22679     static void
22680     SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
22681         swig_varlinkobject *v;
22682         swig_globalvar *gv;
22683         v= (swig_varlinkobject *) p;
22684         gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
22685         gv->name = (char *) malloc(strlen(name)+1);
22686         strcpy(gv->name,name);
22687         gv->get_attr = get_attr;
22688         gv->set_attr = set_attr;
22689         gv->next = v->vars;
22690         v->vars = gv;
22691     }
22692
22693     /* -----------------------------------------------------------------------------
22694      * constants/methods manipulation
22695      * ----------------------------------------------------------------------------- */
22696
22697     /* Install Constants */
22698     static void
22699     SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
22700         PyObject *obj = 0;
22701         size_t i;
22702         for (i = 0; constants[i].type; i++) {
22703             switch(constants[i].type) {
22704                 case SWIG_PY_INT:
22705                 obj = PyInt_FromLong(constants[i].lvalue);
22706                 break;
22707                 case SWIG_PY_FLOAT:
22708                 obj = PyFloat_FromDouble(constants[i].dvalue);
22709                 break;
22710                 case SWIG_PY_STRING:
22711                 if (constants[i].pvalue) {
22712                     obj = PyString_FromString((char *) constants[i].pvalue);
22713                 } else {
22714                     Py_INCREF(Py_None);
22715                     obj = Py_None;
22716                 }
22717                 break;
22718                 case SWIG_PY_POINTER:
22719                 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
22720                 break;
22721                 case SWIG_PY_BINARY:
22722                 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
22723                 break;
22724                 default:
22725                 obj = 0;
22726                 break;
22727             }
22728             if (obj) {
22729                 PyDict_SetItemString(d,constants[i].name,obj);
22730                 Py_DECREF(obj);
22731             }
22732         }
22733     }
22734
22735     /* -----------------------------------------------------------------------------*/
22736     /* Fix SwigMethods to carry the callback ptrs when needed */
22737     /* -----------------------------------------------------------------------------*/
22738
22739     static void
22740     SWIG_Python_FixMethods(PyMethodDef *methods,
22741     swig_const_info *const_table,
22742     swig_type_info **types,
22743     swig_type_info **types_initial) {
22744         size_t i;
22745         for (i = 0; methods[i].ml_name; ++i) {
22746             char *c = methods[i].ml_doc;
22747             if (c && (c = strstr(c, "swig_ptr: "))) {
22748                 int j;
22749                 swig_const_info *ci = 0;
22750                 char *name = c + 10;
22751                 for (j = 0; const_table[j].type; j++) {
22752                     if (strncmp(const_table[j].name, name,
22753                     strlen(const_table[j].name)) == 0) {
22754                         ci = &(const_table[j]);
22755                         break;
22756                     }
22757                 }
22758                 if (ci) {
22759                     size_t shift = (ci->ptype) - types;
22760                     swig_type_info *ty = types_initial[shift];
22761                     size_t ldoc = (c - methods[i].ml_doc);
22762                     size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
22763                     char *ndoc = (char*)malloc(ldoc + lptr + 10);
22764                     char *buff = ndoc;
22765                     void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
22766                     strncpy(buff, methods[i].ml_doc, ldoc);
22767                     buff += ldoc;
22768                     strncpy(buff, "swig_ptr: ", 10);
22769                     buff += 10;
22770                     SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
22771                     methods[i].ml_doc = ndoc;
22772                 }
22773             }
22774         }
22775     }
22776
22777     /* -----------------------------------------------------------------------------*
22778      *  Initialize type list
22779      * -----------------------------------------------------------------------------*/
22780
22781 #if PY_MAJOR_VERSION < 2
22782     /* PyModule_AddObject function was introduced in Python 2.0.  The following function
22783     is copied out of Python/modsupport.c in python version 2.3.4 */
22784     static int
22785     PyModule_AddObject(PyObject *m, char *name, PyObject *o)
22786     {
22787         PyObject *dict;
22788         if (!PyModule_Check(m)) {
22789             PyErr_SetString(PyExc_TypeError,
22790             "PyModule_AddObject() needs module as first arg");
22791             return -1;
22792         }
22793         if (!o) {
22794             PyErr_SetString(PyExc_TypeError,
22795             "PyModule_AddObject() needs non-NULL value");
22796             return -1;
22797         }
22798
22799         dict = PyModule_GetDict(m);
22800         if (dict == NULL) {
22801             /* Internal error -- modules must have a dict! */
22802             PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
22803             PyModule_GetName(m));
22804             return -1;
22805         }
22806         if (PyDict_SetItemString(dict, name, o))
22807         return -1;
22808         Py_DECREF(o);
22809         return 0;
22810     }
22811 #endif
22812
22813     static swig_type_info **
22814     SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
22815         static PyMethodDef swig_empty_runtime_method_table[] = {
22816             {
22817                 NULL, NULL, 0, NULL
22818             }
22819         };/* Sentinel */
22820
22821         PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
22822         swig_empty_runtime_method_table);
22823         PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
22824         if (pointer && module) {
22825             PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
22826         }
22827         return type_list_handle;
22828     }
22829
22830     static swig_type_info **
22831     SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
22832         swig_type_info **type_pointer;
22833
22834         /* first check if module already created */
22835         type_pointer = SWIG_Python_GetTypeListHandle();
22836         if (type_pointer) {
22837             return type_pointer;
22838         } else {
22839             /* create a new module and variable */
22840             return SWIG_Python_SetTypeListHandle(type_list_handle);
22841         }
22842     }
22843
22844 #ifdef __cplusplus
22845 }
22846 #endif
22847
22848 /* -----------------------------------------------------------------------------*
22849  *  Partial Init method
22850  * -----------------------------------------------------------------------------*/
22851
22852 #ifdef SWIG_LINK_RUNTIME
22853 #ifdef __cplusplus
22854 extern "C"
22855 #endif
22856 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
22857 #endif
22858
22859 #ifdef __cplusplus
22860 extern "C"
22861 #endif
22862 SWIGEXPORT(void) SWIG_init(void) {
22863     static PyObject *SWIG_globals = 0;
22864     static int       typeinit = 0;
22865     PyObject *m, *d;
22866     int       i;
22867     if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
22868
22869     /* Fix SwigMethods to carry the callback ptrs when needed */
22870     SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
22871
22872     m = Py_InitModule((char *) SWIG_name, SwigMethods);
22873     d = PyModule_GetDict(m);
22874
22875     if (!typeinit) {
22876 #ifdef SWIG_LINK_RUNTIME
22877         swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
22878 #else
22879 #  ifndef SWIG_STATIC_RUNTIME
22880         swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
22881 #  endif
22882 #endif
22883         for (i = 0; swig_types_initial[i]; i++) {
22884             swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
22885         }
22886         typeinit = 1;
22887     }
22888     SWIG_InstallConstants(d,swig_const_table);
22889
22890     {
22891         PyDict_SetItemString(d,"OutRegion", SWIG_From_int((int)(wxOutRegion)));
22892     }
22893     {
22894         PyDict_SetItemString(d,"PartRegion", SWIG_From_int((int)(wxPartRegion)));
22895     }
22896     {
22897         PyDict_SetItemString(d,"InRegion", SWIG_From_int((int)(wxInRegion)));
22898     }
22899     {
22900         PyDict_SetItemString(d,"FONTFAMILY_DEFAULT", SWIG_From_int((int)(wxFONTFAMILY_DEFAULT)));
22901     }
22902     {
22903         PyDict_SetItemString(d,"FONTFAMILY_DECORATIVE", SWIG_From_int((int)(wxFONTFAMILY_DECORATIVE)));
22904     }
22905     {
22906         PyDict_SetItemString(d,"FONTFAMILY_ROMAN", SWIG_From_int((int)(wxFONTFAMILY_ROMAN)));
22907     }
22908     {
22909         PyDict_SetItemString(d,"FONTFAMILY_SCRIPT", SWIG_From_int((int)(wxFONTFAMILY_SCRIPT)));
22910     }
22911     {
22912         PyDict_SetItemString(d,"FONTFAMILY_SWISS", SWIG_From_int((int)(wxFONTFAMILY_SWISS)));
22913     }
22914     {
22915         PyDict_SetItemString(d,"FONTFAMILY_MODERN", SWIG_From_int((int)(wxFONTFAMILY_MODERN)));
22916     }
22917     {
22918         PyDict_SetItemString(d,"FONTFAMILY_TELETYPE", SWIG_From_int((int)(wxFONTFAMILY_TELETYPE)));
22919     }
22920     {
22921         PyDict_SetItemString(d,"FONTFAMILY_MAX", SWIG_From_int((int)(wxFONTFAMILY_MAX)));
22922     }
22923     {
22924         PyDict_SetItemString(d,"FONTFAMILY_UNKNOWN", SWIG_From_int((int)(wxFONTFAMILY_UNKNOWN)));
22925     }
22926     {
22927         PyDict_SetItemString(d,"FONTSTYLE_NORMAL", SWIG_From_int((int)(wxFONTSTYLE_NORMAL)));
22928     }
22929     {
22930         PyDict_SetItemString(d,"FONTSTYLE_ITALIC", SWIG_From_int((int)(wxFONTSTYLE_ITALIC)));
22931     }
22932     {
22933         PyDict_SetItemString(d,"FONTSTYLE_SLANT", SWIG_From_int((int)(wxFONTSTYLE_SLANT)));
22934     }
22935     {
22936         PyDict_SetItemString(d,"FONTSTYLE_MAX", SWIG_From_int((int)(wxFONTSTYLE_MAX)));
22937     }
22938     {
22939         PyDict_SetItemString(d,"FONTWEIGHT_NORMAL", SWIG_From_int((int)(wxFONTWEIGHT_NORMAL)));
22940     }
22941     {
22942         PyDict_SetItemString(d,"FONTWEIGHT_LIGHT", SWIG_From_int((int)(wxFONTWEIGHT_LIGHT)));
22943     }
22944     {
22945         PyDict_SetItemString(d,"FONTWEIGHT_BOLD", SWIG_From_int((int)(wxFONTWEIGHT_BOLD)));
22946     }
22947     {
22948         PyDict_SetItemString(d,"FONTWEIGHT_MAX", SWIG_From_int((int)(wxFONTWEIGHT_MAX)));
22949     }
22950     {
22951         PyDict_SetItemString(d,"FONTFLAG_DEFAULT", SWIG_From_int((int)(wxFONTFLAG_DEFAULT)));
22952     }
22953     {
22954         PyDict_SetItemString(d,"FONTFLAG_ITALIC", SWIG_From_int((int)(wxFONTFLAG_ITALIC)));
22955     }
22956     {
22957         PyDict_SetItemString(d,"FONTFLAG_SLANT", SWIG_From_int((int)(wxFONTFLAG_SLANT)));
22958     }
22959     {
22960         PyDict_SetItemString(d,"FONTFLAG_LIGHT", SWIG_From_int((int)(wxFONTFLAG_LIGHT)));
22961     }
22962     {
22963         PyDict_SetItemString(d,"FONTFLAG_BOLD", SWIG_From_int((int)(wxFONTFLAG_BOLD)));
22964     }
22965     {
22966         PyDict_SetItemString(d,"FONTFLAG_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_ANTIALIASED)));
22967     }
22968     {
22969         PyDict_SetItemString(d,"FONTFLAG_NOT_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_NOT_ANTIALIASED)));
22970     }
22971     {
22972         PyDict_SetItemString(d,"FONTFLAG_UNDERLINED", SWIG_From_int((int)(wxFONTFLAG_UNDERLINED)));
22973     }
22974     {
22975         PyDict_SetItemString(d,"FONTFLAG_STRIKETHROUGH", SWIG_From_int((int)(wxFONTFLAG_STRIKETHROUGH)));
22976     }
22977     {
22978         PyDict_SetItemString(d,"FONTFLAG_MASK", SWIG_From_int((int)(wxFONTFLAG_MASK)));
22979     }
22980     {
22981         PyDict_SetItemString(d,"FONTENCODING_SYSTEM", SWIG_From_int((int)(wxFONTENCODING_SYSTEM)));
22982     }
22983     {
22984         PyDict_SetItemString(d,"FONTENCODING_DEFAULT", SWIG_From_int((int)(wxFONTENCODING_DEFAULT)));
22985     }
22986     {
22987         PyDict_SetItemString(d,"FONTENCODING_ISO8859_1", SWIG_From_int((int)(wxFONTENCODING_ISO8859_1)));
22988     }
22989     {
22990         PyDict_SetItemString(d,"FONTENCODING_ISO8859_2", SWIG_From_int((int)(wxFONTENCODING_ISO8859_2)));
22991     }
22992     {
22993         PyDict_SetItemString(d,"FONTENCODING_ISO8859_3", SWIG_From_int((int)(wxFONTENCODING_ISO8859_3)));
22994     }
22995     {
22996         PyDict_SetItemString(d,"FONTENCODING_ISO8859_4", SWIG_From_int((int)(wxFONTENCODING_ISO8859_4)));
22997     }
22998     {
22999         PyDict_SetItemString(d,"FONTENCODING_ISO8859_5", SWIG_From_int((int)(wxFONTENCODING_ISO8859_5)));
23000     }
23001     {
23002         PyDict_SetItemString(d,"FONTENCODING_ISO8859_6", SWIG_From_int((int)(wxFONTENCODING_ISO8859_6)));
23003     }
23004     {
23005         PyDict_SetItemString(d,"FONTENCODING_ISO8859_7", SWIG_From_int((int)(wxFONTENCODING_ISO8859_7)));
23006     }
23007     {
23008         PyDict_SetItemString(d,"FONTENCODING_ISO8859_8", SWIG_From_int((int)(wxFONTENCODING_ISO8859_8)));
23009     }
23010     {
23011         PyDict_SetItemString(d,"FONTENCODING_ISO8859_9", SWIG_From_int((int)(wxFONTENCODING_ISO8859_9)));
23012     }
23013     {
23014         PyDict_SetItemString(d,"FONTENCODING_ISO8859_10", SWIG_From_int((int)(wxFONTENCODING_ISO8859_10)));
23015     }
23016     {
23017         PyDict_SetItemString(d,"FONTENCODING_ISO8859_11", SWIG_From_int((int)(wxFONTENCODING_ISO8859_11)));
23018     }
23019     {
23020         PyDict_SetItemString(d,"FONTENCODING_ISO8859_12", SWIG_From_int((int)(wxFONTENCODING_ISO8859_12)));
23021     }
23022     {
23023         PyDict_SetItemString(d,"FONTENCODING_ISO8859_13", SWIG_From_int((int)(wxFONTENCODING_ISO8859_13)));
23024     }
23025     {
23026         PyDict_SetItemString(d,"FONTENCODING_ISO8859_14", SWIG_From_int((int)(wxFONTENCODING_ISO8859_14)));
23027     }
23028     {
23029         PyDict_SetItemString(d,"FONTENCODING_ISO8859_15", SWIG_From_int((int)(wxFONTENCODING_ISO8859_15)));
23030     }
23031     {
23032         PyDict_SetItemString(d,"FONTENCODING_ISO8859_MAX", SWIG_From_int((int)(wxFONTENCODING_ISO8859_MAX)));
23033     }
23034     {
23035         PyDict_SetItemString(d,"FONTENCODING_KOI8", SWIG_From_int((int)(wxFONTENCODING_KOI8)));
23036     }
23037     {
23038         PyDict_SetItemString(d,"FONTENCODING_KOI8_U", SWIG_From_int((int)(wxFONTENCODING_KOI8_U)));
23039     }
23040     {
23041         PyDict_SetItemString(d,"FONTENCODING_ALTERNATIVE", SWIG_From_int((int)(wxFONTENCODING_ALTERNATIVE)));
23042     }
23043     {
23044         PyDict_SetItemString(d,"FONTENCODING_BULGARIAN", SWIG_From_int((int)(wxFONTENCODING_BULGARIAN)));
23045     }
23046     {
23047         PyDict_SetItemString(d,"FONTENCODING_CP437", SWIG_From_int((int)(wxFONTENCODING_CP437)));
23048     }
23049     {
23050         PyDict_SetItemString(d,"FONTENCODING_CP850", SWIG_From_int((int)(wxFONTENCODING_CP850)));
23051     }
23052     {
23053         PyDict_SetItemString(d,"FONTENCODING_CP852", SWIG_From_int((int)(wxFONTENCODING_CP852)));
23054     }
23055     {
23056         PyDict_SetItemString(d,"FONTENCODING_CP855", SWIG_From_int((int)(wxFONTENCODING_CP855)));
23057     }
23058     {
23059         PyDict_SetItemString(d,"FONTENCODING_CP866", SWIG_From_int((int)(wxFONTENCODING_CP866)));
23060     }
23061     {
23062         PyDict_SetItemString(d,"FONTENCODING_CP874", SWIG_From_int((int)(wxFONTENCODING_CP874)));
23063     }
23064     {
23065         PyDict_SetItemString(d,"FONTENCODING_CP932", SWIG_From_int((int)(wxFONTENCODING_CP932)));
23066     }
23067     {
23068         PyDict_SetItemString(d,"FONTENCODING_CP936", SWIG_From_int((int)(wxFONTENCODING_CP936)));
23069     }
23070     {
23071         PyDict_SetItemString(d,"FONTENCODING_CP949", SWIG_From_int((int)(wxFONTENCODING_CP949)));
23072     }
23073     {
23074         PyDict_SetItemString(d,"FONTENCODING_CP950", SWIG_From_int((int)(wxFONTENCODING_CP950)));
23075     }
23076     {
23077         PyDict_SetItemString(d,"FONTENCODING_CP1250", SWIG_From_int((int)(wxFONTENCODING_CP1250)));
23078     }
23079     {
23080         PyDict_SetItemString(d,"FONTENCODING_CP1251", SWIG_From_int((int)(wxFONTENCODING_CP1251)));
23081     }
23082     {
23083         PyDict_SetItemString(d,"FONTENCODING_CP1252", SWIG_From_int((int)(wxFONTENCODING_CP1252)));
23084     }
23085     {
23086         PyDict_SetItemString(d,"FONTENCODING_CP1253", SWIG_From_int((int)(wxFONTENCODING_CP1253)));
23087     }
23088     {
23089         PyDict_SetItemString(d,"FONTENCODING_CP1254", SWIG_From_int((int)(wxFONTENCODING_CP1254)));
23090     }
23091     {
23092         PyDict_SetItemString(d,"FONTENCODING_CP1255", SWIG_From_int((int)(wxFONTENCODING_CP1255)));
23093     }
23094     {
23095         PyDict_SetItemString(d,"FONTENCODING_CP1256", SWIG_From_int((int)(wxFONTENCODING_CP1256)));
23096     }
23097     {
23098         PyDict_SetItemString(d,"FONTENCODING_CP1257", SWIG_From_int((int)(wxFONTENCODING_CP1257)));
23099     }
23100     {
23101         PyDict_SetItemString(d,"FONTENCODING_CP12_MAX", SWIG_From_int((int)(wxFONTENCODING_CP12_MAX)));
23102     }
23103     {
23104         PyDict_SetItemString(d,"FONTENCODING_UTF7", SWIG_From_int((int)(wxFONTENCODING_UTF7)));
23105     }
23106     {
23107         PyDict_SetItemString(d,"FONTENCODING_UTF8", SWIG_From_int((int)(wxFONTENCODING_UTF8)));
23108     }
23109     {
23110         PyDict_SetItemString(d,"FONTENCODING_EUC_JP", SWIG_From_int((int)(wxFONTENCODING_EUC_JP)));
23111     }
23112     {
23113         PyDict_SetItemString(d,"FONTENCODING_UTF16BE", SWIG_From_int((int)(wxFONTENCODING_UTF16BE)));
23114     }
23115     {
23116         PyDict_SetItemString(d,"FONTENCODING_UTF16LE", SWIG_From_int((int)(wxFONTENCODING_UTF16LE)));
23117     }
23118     {
23119         PyDict_SetItemString(d,"FONTENCODING_UTF32BE", SWIG_From_int((int)(wxFONTENCODING_UTF32BE)));
23120     }
23121     {
23122         PyDict_SetItemString(d,"FONTENCODING_UTF32LE", SWIG_From_int((int)(wxFONTENCODING_UTF32LE)));
23123     }
23124     {
23125         PyDict_SetItemString(d,"FONTENCODING_MACROMAN", SWIG_From_int((int)(wxFONTENCODING_MACROMAN)));
23126     }
23127     {
23128         PyDict_SetItemString(d,"FONTENCODING_MACJAPANESE", SWIG_From_int((int)(wxFONTENCODING_MACJAPANESE)));
23129     }
23130     {
23131         PyDict_SetItemString(d,"FONTENCODING_MACCHINESETRAD", SWIG_From_int((int)(wxFONTENCODING_MACCHINESETRAD)));
23132     }
23133     {
23134         PyDict_SetItemString(d,"FONTENCODING_MACKOREAN", SWIG_From_int((int)(wxFONTENCODING_MACKOREAN)));
23135     }
23136     {
23137         PyDict_SetItemString(d,"FONTENCODING_MACARABIC", SWIG_From_int((int)(wxFONTENCODING_MACARABIC)));
23138     }
23139     {
23140         PyDict_SetItemString(d,"FONTENCODING_MACHEBREW", SWIG_From_int((int)(wxFONTENCODING_MACHEBREW)));
23141     }
23142     {
23143         PyDict_SetItemString(d,"FONTENCODING_MACGREEK", SWIG_From_int((int)(wxFONTENCODING_MACGREEK)));
23144     }
23145     {
23146         PyDict_SetItemString(d,"FONTENCODING_MACCYRILLIC", SWIG_From_int((int)(wxFONTENCODING_MACCYRILLIC)));
23147     }
23148     {
23149         PyDict_SetItemString(d,"FONTENCODING_MACDEVANAGARI", SWIG_From_int((int)(wxFONTENCODING_MACDEVANAGARI)));
23150     }
23151     {
23152         PyDict_SetItemString(d,"FONTENCODING_MACGURMUKHI", SWIG_From_int((int)(wxFONTENCODING_MACGURMUKHI)));
23153     }
23154     {
23155         PyDict_SetItemString(d,"FONTENCODING_MACGUJARATI", SWIG_From_int((int)(wxFONTENCODING_MACGUJARATI)));
23156     }
23157     {
23158         PyDict_SetItemString(d,"FONTENCODING_MACORIYA", SWIG_From_int((int)(wxFONTENCODING_MACORIYA)));
23159     }
23160     {
23161         PyDict_SetItemString(d,"FONTENCODING_MACBENGALI", SWIG_From_int((int)(wxFONTENCODING_MACBENGALI)));
23162     }
23163     {
23164         PyDict_SetItemString(d,"FONTENCODING_MACTAMIL", SWIG_From_int((int)(wxFONTENCODING_MACTAMIL)));
23165     }
23166     {
23167         PyDict_SetItemString(d,"FONTENCODING_MACTELUGU", SWIG_From_int((int)(wxFONTENCODING_MACTELUGU)));
23168     }
23169     {
23170         PyDict_SetItemString(d,"FONTENCODING_MACKANNADA", SWIG_From_int((int)(wxFONTENCODING_MACKANNADA)));
23171     }
23172     {
23173         PyDict_SetItemString(d,"FONTENCODING_MACMALAJALAM", SWIG_From_int((int)(wxFONTENCODING_MACMALAJALAM)));
23174     }
23175     {
23176         PyDict_SetItemString(d,"FONTENCODING_MACSINHALESE", SWIG_From_int((int)(wxFONTENCODING_MACSINHALESE)));
23177     }
23178     {
23179         PyDict_SetItemString(d,"FONTENCODING_MACBURMESE", SWIG_From_int((int)(wxFONTENCODING_MACBURMESE)));
23180     }
23181     {
23182         PyDict_SetItemString(d,"FONTENCODING_MACKHMER", SWIG_From_int((int)(wxFONTENCODING_MACKHMER)));
23183     }
23184     {
23185         PyDict_SetItemString(d,"FONTENCODING_MACTHAI", SWIG_From_int((int)(wxFONTENCODING_MACTHAI)));
23186     }
23187     {
23188         PyDict_SetItemString(d,"FONTENCODING_MACLAOTIAN", SWIG_From_int((int)(wxFONTENCODING_MACLAOTIAN)));
23189     }
23190     {
23191         PyDict_SetItemString(d,"FONTENCODING_MACGEORGIAN", SWIG_From_int((int)(wxFONTENCODING_MACGEORGIAN)));
23192     }
23193     {
23194         PyDict_SetItemString(d,"FONTENCODING_MACARMENIAN", SWIG_From_int((int)(wxFONTENCODING_MACARMENIAN)));
23195     }
23196     {
23197         PyDict_SetItemString(d,"FONTENCODING_MACCHINESESIMP", SWIG_From_int((int)(wxFONTENCODING_MACCHINESESIMP)));
23198     }
23199     {
23200         PyDict_SetItemString(d,"FONTENCODING_MACTIBETAN", SWIG_From_int((int)(wxFONTENCODING_MACTIBETAN)));
23201     }
23202     {
23203         PyDict_SetItemString(d,"FONTENCODING_MACMONGOLIAN", SWIG_From_int((int)(wxFONTENCODING_MACMONGOLIAN)));
23204     }
23205     {
23206         PyDict_SetItemString(d,"FONTENCODING_MACETHIOPIC", SWIG_From_int((int)(wxFONTENCODING_MACETHIOPIC)));
23207     }
23208     {
23209         PyDict_SetItemString(d,"FONTENCODING_MACCENTRALEUR", SWIG_From_int((int)(wxFONTENCODING_MACCENTRALEUR)));
23210     }
23211     {
23212         PyDict_SetItemString(d,"FONTENCODING_MACVIATNAMESE", SWIG_From_int((int)(wxFONTENCODING_MACVIATNAMESE)));
23213     }
23214     {
23215         PyDict_SetItemString(d,"FONTENCODING_MACARABICEXT", SWIG_From_int((int)(wxFONTENCODING_MACARABICEXT)));
23216     }
23217     {
23218         PyDict_SetItemString(d,"FONTENCODING_MACSYMBOL", SWIG_From_int((int)(wxFONTENCODING_MACSYMBOL)));
23219     }
23220     {
23221         PyDict_SetItemString(d,"FONTENCODING_MACDINGBATS", SWIG_From_int((int)(wxFONTENCODING_MACDINGBATS)));
23222     }
23223     {
23224         PyDict_SetItemString(d,"FONTENCODING_MACTURKISH", SWIG_From_int((int)(wxFONTENCODING_MACTURKISH)));
23225     }
23226     {
23227         PyDict_SetItemString(d,"FONTENCODING_MACCROATIAN", SWIG_From_int((int)(wxFONTENCODING_MACCROATIAN)));
23228     }
23229     {
23230         PyDict_SetItemString(d,"FONTENCODING_MACICELANDIC", SWIG_From_int((int)(wxFONTENCODING_MACICELANDIC)));
23231     }
23232     {
23233         PyDict_SetItemString(d,"FONTENCODING_MACROMANIAN", SWIG_From_int((int)(wxFONTENCODING_MACROMANIAN)));
23234     }
23235     {
23236         PyDict_SetItemString(d,"FONTENCODING_MACCELTIC", SWIG_From_int((int)(wxFONTENCODING_MACCELTIC)));
23237     }
23238     {
23239         PyDict_SetItemString(d,"FONTENCODING_MACGAELIC", SWIG_From_int((int)(wxFONTENCODING_MACGAELIC)));
23240     }
23241     {
23242         PyDict_SetItemString(d,"FONTENCODING_MACKEYBOARD", SWIG_From_int((int)(wxFONTENCODING_MACKEYBOARD)));
23243     }
23244     {
23245         PyDict_SetItemString(d,"FONTENCODING_MACMIN", SWIG_From_int((int)(wxFONTENCODING_MACMIN)));
23246     }
23247     {
23248         PyDict_SetItemString(d,"FONTENCODING_MACMAX", SWIG_From_int((int)(wxFONTENCODING_MACMAX)));
23249     }
23250     {
23251         PyDict_SetItemString(d,"FONTENCODING_MAX", SWIG_From_int((int)(wxFONTENCODING_MAX)));
23252     }
23253     {
23254         PyDict_SetItemString(d,"FONTENCODING_UTF16", SWIG_From_int((int)(wxFONTENCODING_UTF16)));
23255     }
23256     {
23257         PyDict_SetItemString(d,"FONTENCODING_UTF32", SWIG_From_int((int)(wxFONTENCODING_UTF32)));
23258     }
23259     {
23260         PyDict_SetItemString(d,"FONTENCODING_UNICODE", SWIG_From_int((int)(wxFONTENCODING_UNICODE)));
23261     }
23262     {
23263         PyDict_SetItemString(d,"FONTENCODING_GB2312", SWIG_From_int((int)(wxFONTENCODING_GB2312)));
23264     }
23265     {
23266         PyDict_SetItemString(d,"FONTENCODING_BIG5", SWIG_From_int((int)(wxFONTENCODING_BIG5)));
23267     }
23268     {
23269         PyDict_SetItemString(d,"FONTENCODING_SHIFT_JIS", SWIG_From_int((int)(wxFONTENCODING_SHIFT_JIS)));
23270     }
23271
23272     wxPyPtrTypeMap_Add("wxFontEnumerator", "wxPyFontEnumerator");
23273
23274     {
23275         PyDict_SetItemString(d,"LANGUAGE_DEFAULT", SWIG_From_int((int)(wxLANGUAGE_DEFAULT)));
23276     }
23277     {
23278         PyDict_SetItemString(d,"LANGUAGE_UNKNOWN", SWIG_From_int((int)(wxLANGUAGE_UNKNOWN)));
23279     }
23280     {
23281         PyDict_SetItemString(d,"LANGUAGE_ABKHAZIAN", SWIG_From_int((int)(wxLANGUAGE_ABKHAZIAN)));
23282     }
23283     {
23284         PyDict_SetItemString(d,"LANGUAGE_AFAR", SWIG_From_int((int)(wxLANGUAGE_AFAR)));
23285     }
23286     {
23287         PyDict_SetItemString(d,"LANGUAGE_AFRIKAANS", SWIG_From_int((int)(wxLANGUAGE_AFRIKAANS)));
23288     }
23289     {
23290         PyDict_SetItemString(d,"LANGUAGE_ALBANIAN", SWIG_From_int((int)(wxLANGUAGE_ALBANIAN)));
23291     }
23292     {
23293         PyDict_SetItemString(d,"LANGUAGE_AMHARIC", SWIG_From_int((int)(wxLANGUAGE_AMHARIC)));
23294     }
23295     {
23296         PyDict_SetItemString(d,"LANGUAGE_ARABIC", SWIG_From_int((int)(wxLANGUAGE_ARABIC)));
23297     }
23298     {
23299         PyDict_SetItemString(d,"LANGUAGE_ARABIC_ALGERIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_ALGERIA)));
23300     }
23301     {
23302         PyDict_SetItemString(d,"LANGUAGE_ARABIC_BAHRAIN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_BAHRAIN)));
23303     }
23304     {
23305         PyDict_SetItemString(d,"LANGUAGE_ARABIC_EGYPT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_EGYPT)));
23306     }
23307     {
23308         PyDict_SetItemString(d,"LANGUAGE_ARABIC_IRAQ", SWIG_From_int((int)(wxLANGUAGE_ARABIC_IRAQ)));
23309     }
23310     {
23311         PyDict_SetItemString(d,"LANGUAGE_ARABIC_JORDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_JORDAN)));
23312     }
23313     {
23314         PyDict_SetItemString(d,"LANGUAGE_ARABIC_KUWAIT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_KUWAIT)));
23315     }
23316     {
23317         PyDict_SetItemString(d,"LANGUAGE_ARABIC_LEBANON", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LEBANON)));
23318     }
23319     {
23320         PyDict_SetItemString(d,"LANGUAGE_ARABIC_LIBYA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LIBYA)));
23321     }
23322     {
23323         PyDict_SetItemString(d,"LANGUAGE_ARABIC_MOROCCO", SWIG_From_int((int)(wxLANGUAGE_ARABIC_MOROCCO)));
23324     }
23325     {
23326         PyDict_SetItemString(d,"LANGUAGE_ARABIC_OMAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_OMAN)));
23327     }
23328     {
23329         PyDict_SetItemString(d,"LANGUAGE_ARABIC_QATAR", SWIG_From_int((int)(wxLANGUAGE_ARABIC_QATAR)));
23330     }
23331     {
23332         PyDict_SetItemString(d,"LANGUAGE_ARABIC_SAUDI_ARABIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SAUDI_ARABIA)));
23333     }
23334     {
23335         PyDict_SetItemString(d,"LANGUAGE_ARABIC_SUDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SUDAN)));
23336     }
23337     {
23338         PyDict_SetItemString(d,"LANGUAGE_ARABIC_SYRIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SYRIA)));
23339     }
23340     {
23341         PyDict_SetItemString(d,"LANGUAGE_ARABIC_TUNISIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_TUNISIA)));
23342     }
23343     {
23344         PyDict_SetItemString(d,"LANGUAGE_ARABIC_UAE", SWIG_From_int((int)(wxLANGUAGE_ARABIC_UAE)));
23345     }
23346     {
23347         PyDict_SetItemString(d,"LANGUAGE_ARABIC_YEMEN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_YEMEN)));
23348     }
23349     {
23350         PyDict_SetItemString(d,"LANGUAGE_ARMENIAN", SWIG_From_int((int)(wxLANGUAGE_ARMENIAN)));
23351     }
23352     {
23353         PyDict_SetItemString(d,"LANGUAGE_ASSAMESE", SWIG_From_int((int)(wxLANGUAGE_ASSAMESE)));
23354     }
23355     {
23356         PyDict_SetItemString(d,"LANGUAGE_AYMARA", SWIG_From_int((int)(wxLANGUAGE_AYMARA)));
23357     }
23358     {
23359         PyDict_SetItemString(d,"LANGUAGE_AZERI", SWIG_From_int((int)(wxLANGUAGE_AZERI)));
23360     }
23361     {
23362         PyDict_SetItemString(d,"LANGUAGE_AZERI_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_AZERI_CYRILLIC)));
23363     }
23364     {
23365         PyDict_SetItemString(d,"LANGUAGE_AZERI_LATIN", SWIG_From_int((int)(wxLANGUAGE_AZERI_LATIN)));
23366     }
23367     {
23368         PyDict_SetItemString(d,"LANGUAGE_BASHKIR", SWIG_From_int((int)(wxLANGUAGE_BASHKIR)));
23369     }
23370     {
23371         PyDict_SetItemString(d,"LANGUAGE_BASQUE", SWIG_From_int((int)(wxLANGUAGE_BASQUE)));
23372     }
23373     {
23374         PyDict_SetItemString(d,"LANGUAGE_BELARUSIAN", SWIG_From_int((int)(wxLANGUAGE_BELARUSIAN)));
23375     }
23376     {
23377         PyDict_SetItemString(d,"LANGUAGE_BENGALI", SWIG_From_int((int)(wxLANGUAGE_BENGALI)));
23378     }
23379     {
23380         PyDict_SetItemString(d,"LANGUAGE_BHUTANI", SWIG_From_int((int)(wxLANGUAGE_BHUTANI)));
23381     }
23382     {
23383         PyDict_SetItemString(d,"LANGUAGE_BIHARI", SWIG_From_int((int)(wxLANGUAGE_BIHARI)));
23384     }
23385     {
23386         PyDict_SetItemString(d,"LANGUAGE_BISLAMA", SWIG_From_int((int)(wxLANGUAGE_BISLAMA)));
23387     }
23388     {
23389         PyDict_SetItemString(d,"LANGUAGE_BRETON", SWIG_From_int((int)(wxLANGUAGE_BRETON)));
23390     }
23391     {
23392         PyDict_SetItemString(d,"LANGUAGE_BULGARIAN", SWIG_From_int((int)(wxLANGUAGE_BULGARIAN)));
23393     }
23394     {
23395         PyDict_SetItemString(d,"LANGUAGE_BURMESE", SWIG_From_int((int)(wxLANGUAGE_BURMESE)));
23396     }
23397     {
23398         PyDict_SetItemString(d,"LANGUAGE_CAMBODIAN", SWIG_From_int((int)(wxLANGUAGE_CAMBODIAN)));
23399     }
23400     {
23401         PyDict_SetItemString(d,"LANGUAGE_CATALAN", SWIG_From_int((int)(wxLANGUAGE_CATALAN)));
23402     }
23403     {
23404         PyDict_SetItemString(d,"LANGUAGE_CHINESE", SWIG_From_int((int)(wxLANGUAGE_CHINESE)));
23405     }
23406     {
23407         PyDict_SetItemString(d,"LANGUAGE_CHINESE_SIMPLIFIED", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SIMPLIFIED)));
23408     }
23409     {
23410         PyDict_SetItemString(d,"LANGUAGE_CHINESE_TRADITIONAL", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TRADITIONAL)));
23411     }
23412     {
23413         PyDict_SetItemString(d,"LANGUAGE_CHINESE_HONGKONG", SWIG_From_int((int)(wxLANGUAGE_CHINESE_HONGKONG)));
23414     }
23415     {
23416         PyDict_SetItemString(d,"LANGUAGE_CHINESE_MACAU", SWIG_From_int((int)(wxLANGUAGE_CHINESE_MACAU)));
23417     }
23418     {
23419         PyDict_SetItemString(d,"LANGUAGE_CHINESE_SINGAPORE", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SINGAPORE)));
23420     }
23421     {
23422         PyDict_SetItemString(d,"LANGUAGE_CHINESE_TAIWAN", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TAIWAN)));
23423     }
23424     {
23425         PyDict_SetItemString(d,"LANGUAGE_CORSICAN", SWIG_From_int((int)(wxLANGUAGE_CORSICAN)));
23426     }
23427     {
23428         PyDict_SetItemString(d,"LANGUAGE_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_CROATIAN)));
23429     }
23430     {
23431         PyDict_SetItemString(d,"LANGUAGE_CZECH", SWIG_From_int((int)(wxLANGUAGE_CZECH)));
23432     }
23433     {
23434         PyDict_SetItemString(d,"LANGUAGE_DANISH", SWIG_From_int((int)(wxLANGUAGE_DANISH)));
23435     }
23436     {
23437         PyDict_SetItemString(d,"LANGUAGE_DUTCH", SWIG_From_int((int)(wxLANGUAGE_DUTCH)));
23438     }
23439     {
23440         PyDict_SetItemString(d,"LANGUAGE_DUTCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_DUTCH_BELGIAN)));
23441     }
23442     {
23443         PyDict_SetItemString(d,"LANGUAGE_ENGLISH", SWIG_From_int((int)(wxLANGUAGE_ENGLISH)));
23444     }
23445     {
23446         PyDict_SetItemString(d,"LANGUAGE_ENGLISH_UK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_UK)));
23447     }
23448     {
23449         PyDict_SetItemString(d,"LANGUAGE_ENGLISH_US", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_US)));
23450     }
23451     {
23452         PyDict_SetItemString(d,"LANGUAGE_ENGLISH_AUSTRALIA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_AUSTRALIA)));
23453     }
23454     {
23455         PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BELIZE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BELIZE)));
23456     }
23457     {
23458         PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BOTSWANA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BOTSWANA)));
23459     }
23460     {
23461         PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CANADA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CANADA)));
23462     }
23463     {
23464         PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CARIBBEAN", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CARIBBEAN)));
23465     }
23466     {
23467         PyDict_SetItemString(d,"LANGUAGE_ENGLISH_DENMARK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_DENMARK)));
23468     }
23469     {
23470         PyDict_SetItemString(d,"LANGUAGE_ENGLISH_EIRE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_EIRE)));
23471     }
23472     {
23473         PyDict_SetItemString(d,"LANGUAGE_ENGLISH_JAMAICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_JAMAICA)));
23474     }
23475     {
23476         PyDict_SetItemString(d,"LANGUAGE_ENGLISH_NEW_ZEALAND", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_NEW_ZEALAND)));
23477     }
23478     {
23479         PyDict_SetItemString(d,"LANGUAGE_ENGLISH_PHILIPPINES", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_PHILIPPINES)));
23480     }
23481     {
23482         PyDict_SetItemString(d,"LANGUAGE_ENGLISH_SOUTH_AFRICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_SOUTH_AFRICA)));
23483     }
23484     {
23485         PyDict_SetItemString(d,"LANGUAGE_ENGLISH_TRINIDAD", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_TRINIDAD)));
23486     }
23487     {
23488         PyDict_SetItemString(d,"LANGUAGE_ENGLISH_ZIMBABWE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_ZIMBABWE)));
23489     }
23490     {
23491         PyDict_SetItemString(d,"LANGUAGE_ESPERANTO", SWIG_From_int((int)(wxLANGUAGE_ESPERANTO)));
23492     }
23493     {
23494         PyDict_SetItemString(d,"LANGUAGE_ESTONIAN", SWIG_From_int((int)(wxLANGUAGE_ESTONIAN)));
23495     }
23496     {
23497         PyDict_SetItemString(d,"LANGUAGE_FAEROESE", SWIG_From_int((int)(wxLANGUAGE_FAEROESE)));
23498     }
23499     {
23500         PyDict_SetItemString(d,"LANGUAGE_FARSI", SWIG_From_int((int)(wxLANGUAGE_FARSI)));
23501     }
23502     {
23503         PyDict_SetItemString(d,"LANGUAGE_FIJI", SWIG_From_int((int)(wxLANGUAGE_FIJI)));
23504     }
23505     {
23506         PyDict_SetItemString(d,"LANGUAGE_FINNISH", SWIG_From_int((int)(wxLANGUAGE_FINNISH)));
23507     }
23508     {
23509         PyDict_SetItemString(d,"LANGUAGE_FRENCH", SWIG_From_int((int)(wxLANGUAGE_FRENCH)));
23510     }
23511     {
23512         PyDict_SetItemString(d,"LANGUAGE_FRENCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_BELGIAN)));
23513     }
23514     {
23515         PyDict_SetItemString(d,"LANGUAGE_FRENCH_CANADIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_CANADIAN)));
23516     }
23517     {
23518         PyDict_SetItemString(d,"LANGUAGE_FRENCH_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_FRENCH_LUXEMBOURG)));
23519     }
23520     {
23521         PyDict_SetItemString(d,"LANGUAGE_FRENCH_MONACO", SWIG_From_int((int)(wxLANGUAGE_FRENCH_MONACO)));
23522     }
23523     {
23524         PyDict_SetItemString(d,"LANGUAGE_FRENCH_SWISS", SWIG_From_int((int)(wxLANGUAGE_FRENCH_SWISS)));
23525     }
23526     {
23527         PyDict_SetItemString(d,"LANGUAGE_FRISIAN", SWIG_From_int((int)(wxLANGUAGE_FRISIAN)));
23528     }
23529     {
23530         PyDict_SetItemString(d,"LANGUAGE_GALICIAN", SWIG_From_int((int)(wxLANGUAGE_GALICIAN)));
23531     }
23532     {
23533         PyDict_SetItemString(d,"LANGUAGE_GEORGIAN", SWIG_From_int((int)(wxLANGUAGE_GEORGIAN)));
23534     }
23535     {
23536         PyDict_SetItemString(d,"LANGUAGE_GERMAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN)));
23537     }
23538     {
23539         PyDict_SetItemString(d,"LANGUAGE_GERMAN_AUSTRIAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_AUSTRIAN)));
23540     }
23541     {
23542         PyDict_SetItemString(d,"LANGUAGE_GERMAN_BELGIUM", SWIG_From_int((int)(wxLANGUAGE_GERMAN_BELGIUM)));
23543     }
23544     {
23545         PyDict_SetItemString(d,"LANGUAGE_GERMAN_LIECHTENSTEIN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LIECHTENSTEIN)));
23546     }
23547     {
23548         PyDict_SetItemString(d,"LANGUAGE_GERMAN_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LUXEMBOURG)));
23549     }
23550     {
23551         PyDict_SetItemString(d,"LANGUAGE_GERMAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_GERMAN_SWISS)));
23552     }
23553     {
23554         PyDict_SetItemString(d,"LANGUAGE_GREEK", SWIG_From_int((int)(wxLANGUAGE_GREEK)));
23555     }
23556     {
23557         PyDict_SetItemString(d,"LANGUAGE_GREENLANDIC", SWIG_From_int((int)(wxLANGUAGE_GREENLANDIC)));
23558     }
23559     {
23560         PyDict_SetItemString(d,"LANGUAGE_GUARANI", SWIG_From_int((int)(wxLANGUAGE_GUARANI)));
23561     }
23562     {
23563         PyDict_SetItemString(d,"LANGUAGE_GUJARATI", SWIG_From_int((int)(wxLANGUAGE_GUJARATI)));
23564     }
23565     {
23566         PyDict_SetItemString(d,"LANGUAGE_HAUSA", SWIG_From_int((int)(wxLANGUAGE_HAUSA)));
23567     }
23568     {
23569         PyDict_SetItemString(d,"LANGUAGE_HEBREW", SWIG_From_int((int)(wxLANGUAGE_HEBREW)));
23570     }
23571     {
23572         PyDict_SetItemString(d,"LANGUAGE_HINDI", SWIG_From_int((int)(wxLANGUAGE_HINDI)));
23573     }
23574     {
23575         PyDict_SetItemString(d,"LANGUAGE_HUNGARIAN", SWIG_From_int((int)(wxLANGUAGE_HUNGARIAN)));
23576     }
23577     {
23578         PyDict_SetItemString(d,"LANGUAGE_ICELANDIC", SWIG_From_int((int)(wxLANGUAGE_ICELANDIC)));
23579     }
23580     {
23581         PyDict_SetItemString(d,"LANGUAGE_INDONESIAN", SWIG_From_int((int)(wxLANGUAGE_INDONESIAN)));
23582     }
23583     {
23584         PyDict_SetItemString(d,"LANGUAGE_INTERLINGUA", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUA)));
23585     }
23586     {
23587         PyDict_SetItemString(d,"LANGUAGE_INTERLINGUE", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUE)));
23588     }
23589     {
23590         PyDict_SetItemString(d,"LANGUAGE_INUKTITUT", SWIG_From_int((int)(wxLANGUAGE_INUKTITUT)));
23591     }
23592     {
23593         PyDict_SetItemString(d,"LANGUAGE_INUPIAK", SWIG_From_int((int)(wxLANGUAGE_INUPIAK)));
23594     }
23595     {
23596         PyDict_SetItemString(d,"LANGUAGE_IRISH", SWIG_From_int((int)(wxLANGUAGE_IRISH)));
23597     }
23598     {
23599         PyDict_SetItemString(d,"LANGUAGE_ITALIAN", SWIG_From_int((int)(wxLANGUAGE_ITALIAN)));
23600     }
23601     {
23602         PyDict_SetItemString(d,"LANGUAGE_ITALIAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_ITALIAN_SWISS)));
23603     }
23604     {
23605         PyDict_SetItemString(d,"LANGUAGE_JAPANESE", SWIG_From_int((int)(wxLANGUAGE_JAPANESE)));
23606     }
23607     {
23608         PyDict_SetItemString(d,"LANGUAGE_JAVANESE", SWIG_From_int((int)(wxLANGUAGE_JAVANESE)));
23609     }
23610     {
23611         PyDict_SetItemString(d,"LANGUAGE_KANNADA", SWIG_From_int((int)(wxLANGUAGE_KANNADA)));
23612     }
23613     {
23614         PyDict_SetItemString(d,"LANGUAGE_KASHMIRI", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI)));
23615     }
23616     {
23617         PyDict_SetItemString(d,"LANGUAGE_KASHMIRI_INDIA", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI_INDIA)));
23618     }
23619     {
23620         PyDict_SetItemString(d,"LANGUAGE_KAZAKH", SWIG_From_int((int)(wxLANGUAGE_KAZAKH)));
23621     }
23622     {
23623         PyDict_SetItemString(d,"LANGUAGE_KERNEWEK", SWIG_From_int((int)(wxLANGUAGE_KERNEWEK)));
23624     }
23625     {
23626         PyDict_SetItemString(d,"LANGUAGE_KINYARWANDA", SWIG_From_int((int)(wxLANGUAGE_KINYARWANDA)));
23627     }
23628     {
23629         PyDict_SetItemString(d,"LANGUAGE_KIRGHIZ", SWIG_From_int((int)(wxLANGUAGE_KIRGHIZ)));
23630     }
23631     {
23632         PyDict_SetItemString(d,"LANGUAGE_KIRUNDI", SWIG_From_int((int)(wxLANGUAGE_KIRUNDI)));
23633     }
23634     {
23635         PyDict_SetItemString(d,"LANGUAGE_KONKANI", SWIG_From_int((int)(wxLANGUAGE_KONKANI)));
23636     }
23637     {
23638         PyDict_SetItemString(d,"LANGUAGE_KOREAN", SWIG_From_int((int)(wxLANGUAGE_KOREAN)));
23639     }
23640     {
23641         PyDict_SetItemString(d,"LANGUAGE_KURDISH", SWIG_From_int((int)(wxLANGUAGE_KURDISH)));
23642     }
23643     {
23644         PyDict_SetItemString(d,"LANGUAGE_LAOTHIAN", SWIG_From_int((int)(wxLANGUAGE_LAOTHIAN)));
23645     }
23646     {
23647         PyDict_SetItemString(d,"LANGUAGE_LATIN", SWIG_From_int((int)(wxLANGUAGE_LATIN)));
23648     }
23649     {
23650         PyDict_SetItemString(d,"LANGUAGE_LATVIAN", SWIG_From_int((int)(wxLANGUAGE_LATVIAN)));
23651     }
23652     {
23653         PyDict_SetItemString(d,"LANGUAGE_LINGALA", SWIG_From_int((int)(wxLANGUAGE_LINGALA)));
23654     }
23655     {
23656         PyDict_SetItemString(d,"LANGUAGE_LITHUANIAN", SWIG_From_int((int)(wxLANGUAGE_LITHUANIAN)));
23657     }
23658     {
23659         PyDict_SetItemString(d,"LANGUAGE_MACEDONIAN", SWIG_From_int((int)(wxLANGUAGE_MACEDONIAN)));
23660     }
23661     {
23662         PyDict_SetItemString(d,"LANGUAGE_MALAGASY", SWIG_From_int((int)(wxLANGUAGE_MALAGASY)));
23663     }
23664     {
23665         PyDict_SetItemString(d,"LANGUAGE_MALAY", SWIG_From_int((int)(wxLANGUAGE_MALAY)));
23666     }
23667     {
23668         PyDict_SetItemString(d,"LANGUAGE_MALAYALAM", SWIG_From_int((int)(wxLANGUAGE_MALAYALAM)));
23669     }
23670     {
23671         PyDict_SetItemString(d,"LANGUAGE_MALAY_BRUNEI_DARUSSALAM", SWIG_From_int((int)(wxLANGUAGE_MALAY_BRUNEI_DARUSSALAM)));
23672     }
23673     {
23674         PyDict_SetItemString(d,"LANGUAGE_MALAY_MALAYSIA", SWIG_From_int((int)(wxLANGUAGE_MALAY_MALAYSIA)));
23675     }
23676     {
23677         PyDict_SetItemString(d,"LANGUAGE_MALTESE", SWIG_From_int((int)(wxLANGUAGE_MALTESE)));
23678     }
23679     {
23680         PyDict_SetItemString(d,"LANGUAGE_MANIPURI", SWIG_From_int((int)(wxLANGUAGE_MANIPURI)));
23681     }
23682     {
23683         PyDict_SetItemString(d,"LANGUAGE_MAORI", SWIG_From_int((int)(wxLANGUAGE_MAORI)));
23684     }
23685     {
23686         PyDict_SetItemString(d,"LANGUAGE_MARATHI", SWIG_From_int((int)(wxLANGUAGE_MARATHI)));
23687     }
23688     {
23689         PyDict_SetItemString(d,"LANGUAGE_MOLDAVIAN", SWIG_From_int((int)(wxLANGUAGE_MOLDAVIAN)));
23690     }
23691     {
23692         PyDict_SetItemString(d,"LANGUAGE_MONGOLIAN", SWIG_From_int((int)(wxLANGUAGE_MONGOLIAN)));
23693     }
23694     {
23695         PyDict_SetItemString(d,"LANGUAGE_NAURU", SWIG_From_int((int)(wxLANGUAGE_NAURU)));
23696     }
23697     {
23698         PyDict_SetItemString(d,"LANGUAGE_NEPALI", SWIG_From_int((int)(wxLANGUAGE_NEPALI)));
23699     }
23700     {
23701         PyDict_SetItemString(d,"LANGUAGE_NEPALI_INDIA", SWIG_From_int((int)(wxLANGUAGE_NEPALI_INDIA)));
23702     }
23703     {
23704         PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_BOKMAL", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_BOKMAL)));
23705     }
23706     {
23707         PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_NYNORSK", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_NYNORSK)));
23708     }
23709     {
23710         PyDict_SetItemString(d,"LANGUAGE_OCCITAN", SWIG_From_int((int)(wxLANGUAGE_OCCITAN)));
23711     }
23712     {
23713         PyDict_SetItemString(d,"LANGUAGE_ORIYA", SWIG_From_int((int)(wxLANGUAGE_ORIYA)));
23714     }
23715     {
23716         PyDict_SetItemString(d,"LANGUAGE_OROMO", SWIG_From_int((int)(wxLANGUAGE_OROMO)));
23717     }
23718     {
23719         PyDict_SetItemString(d,"LANGUAGE_PASHTO", SWIG_From_int((int)(wxLANGUAGE_PASHTO)));
23720     }
23721     {
23722         PyDict_SetItemString(d,"LANGUAGE_POLISH", SWIG_From_int((int)(wxLANGUAGE_POLISH)));
23723     }
23724     {
23725         PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE)));
23726     }
23727     {
23728         PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE_BRAZILIAN", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE_BRAZILIAN)));
23729     }
23730     {
23731         PyDict_SetItemString(d,"LANGUAGE_PUNJABI", SWIG_From_int((int)(wxLANGUAGE_PUNJABI)));
23732     }
23733     {
23734         PyDict_SetItemString(d,"LANGUAGE_QUECHUA", SWIG_From_int((int)(wxLANGUAGE_QUECHUA)));
23735     }
23736     {
23737         PyDict_SetItemString(d,"LANGUAGE_RHAETO_ROMANCE", SWIG_From_int((int)(wxLANGUAGE_RHAETO_ROMANCE)));
23738     }
23739     {
23740         PyDict_SetItemString(d,"LANGUAGE_ROMANIAN", SWIG_From_int((int)(wxLANGUAGE_ROMANIAN)));
23741     }
23742     {
23743         PyDict_SetItemString(d,"LANGUAGE_RUSSIAN", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN)));
23744     }
23745     {
23746         PyDict_SetItemString(d,"LANGUAGE_RUSSIAN_UKRAINE", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN_UKRAINE)));
23747     }
23748     {
23749         PyDict_SetItemString(d,"LANGUAGE_SAMOAN", SWIG_From_int((int)(wxLANGUAGE_SAMOAN)));
23750     }
23751     {
23752         PyDict_SetItemString(d,"LANGUAGE_SANGHO", SWIG_From_int((int)(wxLANGUAGE_SANGHO)));
23753     }
23754     {
23755         PyDict_SetItemString(d,"LANGUAGE_SANSKRIT", SWIG_From_int((int)(wxLANGUAGE_SANSKRIT)));
23756     }
23757     {
23758         PyDict_SetItemString(d,"LANGUAGE_SCOTS_GAELIC", SWIG_From_int((int)(wxLANGUAGE_SCOTS_GAELIC)));
23759     }
23760     {
23761         PyDict_SetItemString(d,"LANGUAGE_SERBIAN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN)));
23762     }
23763     {
23764         PyDict_SetItemString(d,"LANGUAGE_SERBIAN_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_CYRILLIC)));
23765     }
23766     {
23767         PyDict_SetItemString(d,"LANGUAGE_SERBIAN_LATIN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_LATIN)));
23768     }
23769     {
23770         PyDict_SetItemString(d,"LANGUAGE_SERBO_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_SERBO_CROATIAN)));
23771     }
23772     {
23773         PyDict_SetItemString(d,"LANGUAGE_SESOTHO", SWIG_From_int((int)(wxLANGUAGE_SESOTHO)));
23774     }
23775     {
23776         PyDict_SetItemString(d,"LANGUAGE_SETSWANA", SWIG_From_int((int)(wxLANGUAGE_SETSWANA)));
23777     }
23778     {
23779         PyDict_SetItemString(d,"LANGUAGE_SHONA", SWIG_From_int((int)(wxLANGUAGE_SHONA)));
23780     }
23781     {
23782         PyDict_SetItemString(d,"LANGUAGE_SINDHI", SWIG_From_int((int)(wxLANGUAGE_SINDHI)));
23783     }
23784     {
23785         PyDict_SetItemString(d,"LANGUAGE_SINHALESE", SWIG_From_int((int)(wxLANGUAGE_SINHALESE)));
23786     }
23787     {
23788         PyDict_SetItemString(d,"LANGUAGE_SISWATI", SWIG_From_int((int)(wxLANGUAGE_SISWATI)));
23789     }
23790     {
23791         PyDict_SetItemString(d,"LANGUAGE_SLOVAK", SWIG_From_int((int)(wxLANGUAGE_SLOVAK)));
23792     }
23793     {
23794         PyDict_SetItemString(d,"LANGUAGE_SLOVENIAN", SWIG_From_int((int)(wxLANGUAGE_SLOVENIAN)));
23795     }
23796     {
23797         PyDict_SetItemString(d,"LANGUAGE_SOMALI", SWIG_From_int((int)(wxLANGUAGE_SOMALI)));
23798     }
23799     {
23800         PyDict_SetItemString(d,"LANGUAGE_SPANISH", SWIG_From_int((int)(wxLANGUAGE_SPANISH)));
23801     }
23802     {
23803         PyDict_SetItemString(d,"LANGUAGE_SPANISH_ARGENTINA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ARGENTINA)));
23804     }
23805     {
23806         PyDict_SetItemString(d,"LANGUAGE_SPANISH_BOLIVIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_BOLIVIA)));
23807     }
23808     {
23809         PyDict_SetItemString(d,"LANGUAGE_SPANISH_CHILE", SWIG_From_int((int)(wxLANGUAGE_SPANISH_CHILE)));
23810     }
23811     {
23812         PyDict_SetItemString(d,"LANGUAGE_SPANISH_COLOMBIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COLOMBIA)));
23813     }
23814     {
23815         PyDict_SetItemString(d,"LANGUAGE_SPANISH_COSTA_RICA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COSTA_RICA)));
23816     }
23817     {
23818         PyDict_SetItemString(d,"LANGUAGE_SPANISH_DOMINICAN_REPUBLIC", SWIG_From_int((int)(wxLANGUAGE_SPANISH_DOMINICAN_REPUBLIC)));
23819     }
23820     {
23821         PyDict_SetItemString(d,"LANGUAGE_SPANISH_ECUADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ECUADOR)));
23822     }
23823     {
23824         PyDict_SetItemString(d,"LANGUAGE_SPANISH_EL_SALVADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_EL_SALVADOR)));
23825     }
23826     {
23827         PyDict_SetItemString(d,"LANGUAGE_SPANISH_GUATEMALA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_GUATEMALA)));
23828     }
23829     {
23830         PyDict_SetItemString(d,"LANGUAGE_SPANISH_HONDURAS", SWIG_From_int((int)(wxLANGUAGE_SPANISH_HONDURAS)));
23831     }
23832     {
23833         PyDict_SetItemString(d,"LANGUAGE_SPANISH_MEXICAN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MEXICAN)));
23834     }
23835     {
23836         PyDict_SetItemString(d,"LANGUAGE_SPANISH_MODERN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MODERN)));
23837     }
23838     {
23839         PyDict_SetItemString(d,"LANGUAGE_SPANISH_NICARAGUA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_NICARAGUA)));
23840     }
23841     {
23842         PyDict_SetItemString(d,"LANGUAGE_SPANISH_PANAMA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PANAMA)));
23843     }
23844     {
23845         PyDict_SetItemString(d,"LANGUAGE_SPANISH_PARAGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PARAGUAY)));
23846     }
23847     {
23848         PyDict_SetItemString(d,"LANGUAGE_SPANISH_PERU", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PERU)));
23849     }
23850     {
23851         PyDict_SetItemString(d,"LANGUAGE_SPANISH_PUERTO_RICO", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PUERTO_RICO)));
23852     }
23853     {
23854         PyDict_SetItemString(d,"LANGUAGE_SPANISH_URUGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_URUGUAY)));
23855     }
23856     {
23857         PyDict_SetItemString(d,"LANGUAGE_SPANISH_US", SWIG_From_int((int)(wxLANGUAGE_SPANISH_US)));
23858     }
23859     {
23860         PyDict_SetItemString(d,"LANGUAGE_SPANISH_VENEZUELA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_VENEZUELA)));
23861     }
23862     {
23863         PyDict_SetItemString(d,"LANGUAGE_SUNDANESE", SWIG_From_int((int)(wxLANGUAGE_SUNDANESE)));
23864     }
23865     {
23866         PyDict_SetItemString(d,"LANGUAGE_SWAHILI", SWIG_From_int((int)(wxLANGUAGE_SWAHILI)));
23867     }
23868     {
23869         PyDict_SetItemString(d,"LANGUAGE_SWEDISH", SWIG_From_int((int)(wxLANGUAGE_SWEDISH)));
23870     }
23871     {
23872         PyDict_SetItemString(d,"LANGUAGE_SWEDISH_FINLAND", SWIG_From_int((int)(wxLANGUAGE_SWEDISH_FINLAND)));
23873     }
23874     {
23875         PyDict_SetItemString(d,"LANGUAGE_TAGALOG", SWIG_From_int((int)(wxLANGUAGE_TAGALOG)));
23876     }
23877     {
23878         PyDict_SetItemString(d,"LANGUAGE_TAJIK", SWIG_From_int((int)(wxLANGUAGE_TAJIK)));
23879     }
23880     {
23881         PyDict_SetItemString(d,"LANGUAGE_TAMIL", SWIG_From_int((int)(wxLANGUAGE_TAMIL)));
23882     }
23883     {
23884         PyDict_SetItemString(d,"LANGUAGE_TATAR", SWIG_From_int((int)(wxLANGUAGE_TATAR)));
23885     }
23886     {
23887         PyDict_SetItemString(d,"LANGUAGE_TELUGU", SWIG_From_int((int)(wxLANGUAGE_TELUGU)));
23888     }
23889     {
23890         PyDict_SetItemString(d,"LANGUAGE_THAI", SWIG_From_int((int)(wxLANGUAGE_THAI)));
23891     }
23892     {
23893         PyDict_SetItemString(d,"LANGUAGE_TIBETAN", SWIG_From_int((int)(wxLANGUAGE_TIBETAN)));
23894     }
23895     {
23896         PyDict_SetItemString(d,"LANGUAGE_TIGRINYA", SWIG_From_int((int)(wxLANGUAGE_TIGRINYA)));
23897     }
23898     {
23899         PyDict_SetItemString(d,"LANGUAGE_TONGA", SWIG_From_int((int)(wxLANGUAGE_TONGA)));
23900     }
23901     {
23902         PyDict_SetItemString(d,"LANGUAGE_TSONGA", SWIG_From_int((int)(wxLANGUAGE_TSONGA)));
23903     }
23904     {
23905         PyDict_SetItemString(d,"LANGUAGE_TURKISH", SWIG_From_int((int)(wxLANGUAGE_TURKISH)));
23906     }
23907     {
23908         PyDict_SetItemString(d,"LANGUAGE_TURKMEN", SWIG_From_int((int)(wxLANGUAGE_TURKMEN)));
23909     }
23910     {
23911         PyDict_SetItemString(d,"LANGUAGE_TWI", SWIG_From_int((int)(wxLANGUAGE_TWI)));
23912     }
23913     {
23914         PyDict_SetItemString(d,"LANGUAGE_UIGHUR", SWIG_From_int((int)(wxLANGUAGE_UIGHUR)));
23915     }
23916     {
23917         PyDict_SetItemString(d,"LANGUAGE_UKRAINIAN", SWIG_From_int((int)(wxLANGUAGE_UKRAINIAN)));
23918     }
23919     {
23920         PyDict_SetItemString(d,"LANGUAGE_URDU", SWIG_From_int((int)(wxLANGUAGE_URDU)));
23921     }
23922     {
23923         PyDict_SetItemString(d,"LANGUAGE_URDU_INDIA", SWIG_From_int((int)(wxLANGUAGE_URDU_INDIA)));
23924     }
23925     {
23926         PyDict_SetItemString(d,"LANGUAGE_URDU_PAKISTAN", SWIG_From_int((int)(wxLANGUAGE_URDU_PAKISTAN)));
23927     }
23928     {
23929         PyDict_SetItemString(d,"LANGUAGE_UZBEK", SWIG_From_int((int)(wxLANGUAGE_UZBEK)));
23930     }
23931     {
23932         PyDict_SetItemString(d,"LANGUAGE_UZBEK_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_UZBEK_CYRILLIC)));
23933     }
23934     {
23935         PyDict_SetItemString(d,"LANGUAGE_UZBEK_LATIN", SWIG_From_int((int)(wxLANGUAGE_UZBEK_LATIN)));
23936     }
23937     {
23938         PyDict_SetItemString(d,"LANGUAGE_VIETNAMESE", SWIG_From_int((int)(wxLANGUAGE_VIETNAMESE)));
23939     }
23940     {
23941         PyDict_SetItemString(d,"LANGUAGE_VOLAPUK", SWIG_From_int((int)(wxLANGUAGE_VOLAPUK)));
23942     }
23943     {
23944         PyDict_SetItemString(d,"LANGUAGE_WELSH", SWIG_From_int((int)(wxLANGUAGE_WELSH)));
23945     }
23946     {
23947         PyDict_SetItemString(d,"LANGUAGE_WOLOF", SWIG_From_int((int)(wxLANGUAGE_WOLOF)));
23948     }
23949     {
23950         PyDict_SetItemString(d,"LANGUAGE_XHOSA", SWIG_From_int((int)(wxLANGUAGE_XHOSA)));
23951     }
23952     {
23953         PyDict_SetItemString(d,"LANGUAGE_YIDDISH", SWIG_From_int((int)(wxLANGUAGE_YIDDISH)));
23954     }
23955     {
23956         PyDict_SetItemString(d,"LANGUAGE_YORUBA", SWIG_From_int((int)(wxLANGUAGE_YORUBA)));
23957     }
23958     {
23959         PyDict_SetItemString(d,"LANGUAGE_ZHUANG", SWIG_From_int((int)(wxLANGUAGE_ZHUANG)));
23960     }
23961     {
23962         PyDict_SetItemString(d,"LANGUAGE_ZULU", SWIG_From_int((int)(wxLANGUAGE_ZULU)));
23963     }
23964     {
23965         PyDict_SetItemString(d,"LANGUAGE_USER_DEFINED", SWIG_From_int((int)(wxLANGUAGE_USER_DEFINED)));
23966     }
23967     {
23968         PyDict_SetItemString(d,"LOCALE_CAT_NUMBER", SWIG_From_int((int)(wxLOCALE_CAT_NUMBER)));
23969     }
23970     {
23971         PyDict_SetItemString(d,"LOCALE_CAT_DATE", SWIG_From_int((int)(wxLOCALE_CAT_DATE)));
23972     }
23973     {
23974         PyDict_SetItemString(d,"LOCALE_CAT_MONEY", SWIG_From_int((int)(wxLOCALE_CAT_MONEY)));
23975     }
23976     {
23977         PyDict_SetItemString(d,"LOCALE_CAT_MAX", SWIG_From_int((int)(wxLOCALE_CAT_MAX)));
23978     }
23979     {
23980         PyDict_SetItemString(d,"LOCALE_THOUSANDS_SEP", SWIG_From_int((int)(wxLOCALE_THOUSANDS_SEP)));
23981     }
23982     {
23983         PyDict_SetItemString(d,"LOCALE_DECIMAL_POINT", SWIG_From_int((int)(wxLOCALE_DECIMAL_POINT)));
23984     }
23985     {
23986         PyDict_SetItemString(d,"LOCALE_LOAD_DEFAULT", SWIG_From_int((int)(wxLOCALE_LOAD_DEFAULT)));
23987     }
23988     {
23989         PyDict_SetItemString(d,"LOCALE_CONV_ENCODING", SWIG_From_int((int)(wxLOCALE_CONV_ENCODING)));
23990     }
23991     {
23992         PyDict_SetItemString(d,"CONVERT_STRICT", SWIG_From_int((int)(wxCONVERT_STRICT)));
23993     }
23994     {
23995         PyDict_SetItemString(d,"CONVERT_SUBSTITUTE", SWIG_From_int((int)(wxCONVERT_SUBSTITUTE)));
23996     }
23997     {
23998         PyDict_SetItemString(d,"PLATFORM_CURRENT", SWIG_From_int((int)(wxPLATFORM_CURRENT)));
23999     }
24000     {
24001         PyDict_SetItemString(d,"PLATFORM_UNIX", SWIG_From_int((int)(wxPLATFORM_UNIX)));
24002     }
24003     {
24004         PyDict_SetItemString(d,"PLATFORM_WINDOWS", SWIG_From_int((int)(wxPLATFORM_WINDOWS)));
24005     }
24006     {
24007         PyDict_SetItemString(d,"PLATFORM_OS2", SWIG_From_int((int)(wxPLATFORM_OS2)));
24008     }
24009     {
24010         PyDict_SetItemString(d,"PLATFORM_MAC", SWIG_From_int((int)(wxPLATFORM_MAC)));
24011     }
24012     {
24013         PyDict_SetItemString(d,"BUFFER_VIRTUAL_AREA", SWIG_From_int((int)(wxBUFFER_VIRTUAL_AREA)));
24014     }
24015     {
24016         PyDict_SetItemString(d,"BUFFER_CLIENT_AREA", SWIG_From_int((int)(wxBUFFER_CLIENT_AREA)));
24017     }
24018     {
24019         PyDict_SetItemString(d,"IMAGELIST_DRAW_NORMAL", SWIG_From_int((int)(wxIMAGELIST_DRAW_NORMAL)));
24020     }
24021     {
24022         PyDict_SetItemString(d,"IMAGELIST_DRAW_TRANSPARENT", SWIG_From_int((int)(wxIMAGELIST_DRAW_TRANSPARENT)));
24023     }
24024     {
24025         PyDict_SetItemString(d,"IMAGELIST_DRAW_SELECTED", SWIG_From_int((int)(wxIMAGELIST_DRAW_SELECTED)));
24026     }
24027     {
24028         PyDict_SetItemString(d,"IMAGELIST_DRAW_FOCUSED", SWIG_From_int((int)(wxIMAGELIST_DRAW_FOCUSED)));
24029     }
24030     {
24031         PyDict_SetItemString(d,"IMAGE_LIST_NORMAL", SWIG_From_int((int)(wxIMAGE_LIST_NORMAL)));
24032     }
24033     {
24034         PyDict_SetItemString(d,"IMAGE_LIST_SMALL", SWIG_From_int((int)(wxIMAGE_LIST_SMALL)));
24035     }
24036     {
24037         PyDict_SetItemString(d,"IMAGE_LIST_STATE", SWIG_From_int((int)(wxIMAGE_LIST_STATE)));
24038     }
24039     PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
24040     SWIG_addvarlink(SWIG_globals,(char*)"NORMAL_FONT",_wrap_NORMAL_FONT_get, _wrap_NORMAL_FONT_set);
24041     SWIG_addvarlink(SWIG_globals,(char*)"SMALL_FONT",_wrap_SMALL_FONT_get, _wrap_SMALL_FONT_set);
24042     SWIG_addvarlink(SWIG_globals,(char*)"ITALIC_FONT",_wrap_ITALIC_FONT_get, _wrap_ITALIC_FONT_set);
24043     SWIG_addvarlink(SWIG_globals,(char*)"SWISS_FONT",_wrap_SWISS_FONT_get, _wrap_SWISS_FONT_set);
24044     SWIG_addvarlink(SWIG_globals,(char*)"RED_PEN",_wrap_RED_PEN_get, _wrap_RED_PEN_set);
24045     SWIG_addvarlink(SWIG_globals,(char*)"CYAN_PEN",_wrap_CYAN_PEN_get, _wrap_CYAN_PEN_set);
24046     SWIG_addvarlink(SWIG_globals,(char*)"GREEN_PEN",_wrap_GREEN_PEN_get, _wrap_GREEN_PEN_set);
24047     SWIG_addvarlink(SWIG_globals,(char*)"BLACK_PEN",_wrap_BLACK_PEN_get, _wrap_BLACK_PEN_set);
24048     SWIG_addvarlink(SWIG_globals,(char*)"WHITE_PEN",_wrap_WHITE_PEN_get, _wrap_WHITE_PEN_set);
24049     SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_PEN",_wrap_TRANSPARENT_PEN_get, _wrap_TRANSPARENT_PEN_set);
24050     SWIG_addvarlink(SWIG_globals,(char*)"BLACK_DASHED_PEN",_wrap_BLACK_DASHED_PEN_get, _wrap_BLACK_DASHED_PEN_set);
24051     SWIG_addvarlink(SWIG_globals,(char*)"GREY_PEN",_wrap_GREY_PEN_get, _wrap_GREY_PEN_set);
24052     SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_PEN",_wrap_MEDIUM_GREY_PEN_get, _wrap_MEDIUM_GREY_PEN_set);
24053     SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_PEN",_wrap_LIGHT_GREY_PEN_get, _wrap_LIGHT_GREY_PEN_set);
24054     SWIG_addvarlink(SWIG_globals,(char*)"BLUE_BRUSH",_wrap_BLUE_BRUSH_get, _wrap_BLUE_BRUSH_set);
24055     SWIG_addvarlink(SWIG_globals,(char*)"GREEN_BRUSH",_wrap_GREEN_BRUSH_get, _wrap_GREEN_BRUSH_set);
24056     SWIG_addvarlink(SWIG_globals,(char*)"WHITE_BRUSH",_wrap_WHITE_BRUSH_get, _wrap_WHITE_BRUSH_set);
24057     SWIG_addvarlink(SWIG_globals,(char*)"BLACK_BRUSH",_wrap_BLACK_BRUSH_get, _wrap_BLACK_BRUSH_set);
24058     SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_BRUSH",_wrap_TRANSPARENT_BRUSH_get, _wrap_TRANSPARENT_BRUSH_set);
24059     SWIG_addvarlink(SWIG_globals,(char*)"CYAN_BRUSH",_wrap_CYAN_BRUSH_get, _wrap_CYAN_BRUSH_set);
24060     SWIG_addvarlink(SWIG_globals,(char*)"RED_BRUSH",_wrap_RED_BRUSH_get, _wrap_RED_BRUSH_set);
24061     SWIG_addvarlink(SWIG_globals,(char*)"GREY_BRUSH",_wrap_GREY_BRUSH_get, _wrap_GREY_BRUSH_set);
24062     SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_BRUSH",_wrap_MEDIUM_GREY_BRUSH_get, _wrap_MEDIUM_GREY_BRUSH_set);
24063     SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_BRUSH",_wrap_LIGHT_GREY_BRUSH_get, _wrap_LIGHT_GREY_BRUSH_set);
24064     SWIG_addvarlink(SWIG_globals,(char*)"BLACK",_wrap_BLACK_get, _wrap_BLACK_set);
24065     SWIG_addvarlink(SWIG_globals,(char*)"WHITE",_wrap_WHITE_get, _wrap_WHITE_set);
24066     SWIG_addvarlink(SWIG_globals,(char*)"RED",_wrap_RED_get, _wrap_RED_set);
24067     SWIG_addvarlink(SWIG_globals,(char*)"BLUE",_wrap_BLUE_get, _wrap_BLUE_set);
24068     SWIG_addvarlink(SWIG_globals,(char*)"GREEN",_wrap_GREEN_get, _wrap_GREEN_set);
24069     SWIG_addvarlink(SWIG_globals,(char*)"CYAN",_wrap_CYAN_get, _wrap_CYAN_set);
24070     SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY",_wrap_LIGHT_GREY_get, _wrap_LIGHT_GREY_set);
24071     SWIG_addvarlink(SWIG_globals,(char*)"STANDARD_CURSOR",_wrap_STANDARD_CURSOR_get, _wrap_STANDARD_CURSOR_set);
24072     SWIG_addvarlink(SWIG_globals,(char*)"HOURGLASS_CURSOR",_wrap_HOURGLASS_CURSOR_get, _wrap_HOURGLASS_CURSOR_set);
24073     SWIG_addvarlink(SWIG_globals,(char*)"CROSS_CURSOR",_wrap_CROSS_CURSOR_get, _wrap_CROSS_CURSOR_set);
24074     SWIG_addvarlink(SWIG_globals,(char*)"NullBitmap",_wrap_NullBitmap_get, _wrap_NullBitmap_set);
24075     SWIG_addvarlink(SWIG_globals,(char*)"NullIcon",_wrap_NullIcon_get, _wrap_NullIcon_set);
24076     SWIG_addvarlink(SWIG_globals,(char*)"NullCursor",_wrap_NullCursor_get, _wrap_NullCursor_set);
24077     SWIG_addvarlink(SWIG_globals,(char*)"NullPen",_wrap_NullPen_get, _wrap_NullPen_set);
24078     SWIG_addvarlink(SWIG_globals,(char*)"NullBrush",_wrap_NullBrush_get, _wrap_NullBrush_set);
24079     SWIG_addvarlink(SWIG_globals,(char*)"NullPalette",_wrap_NullPalette_get, _wrap_NullPalette_set);
24080     SWIG_addvarlink(SWIG_globals,(char*)"NullFont",_wrap_NullFont_get, _wrap_NullFont_set);
24081     SWIG_addvarlink(SWIG_globals,(char*)"NullColour",_wrap_NullColour_get, _wrap_NullColour_set);
24082     SWIG_addvarlink(SWIG_globals,(char*)"TheFontList",_wrap_TheFontList_get, _wrap_TheFontList_set);
24083     SWIG_addvarlink(SWIG_globals,(char*)"ThePenList",_wrap_ThePenList_get, _wrap_ThePenList_set);
24084     SWIG_addvarlink(SWIG_globals,(char*)"TheBrushList",_wrap_TheBrushList_get, _wrap_TheBrushList_set);
24085     SWIG_addvarlink(SWIG_globals,(char*)"TheColourDatabase",_wrap_TheColourDatabase_get, _wrap_TheColourDatabase_set);
24086
24087     // Work around a chicken/egg problem in drawlist.cpp
24088     wxPyDrawList_SetAPIPtr();
24089
24090 }
24091