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         Py_DECREF(str);
1041         return;
1042       }
1043     }
1044     PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045   } else {
1046     PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047   }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053   if (type) {
1054     PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055   } else {
1056     PyErr_Format(PyExc_TypeError, "null reference was received");
1057   }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063   if (PyErr_Occurred()) {
1064     PyObject *type = 0;
1065     PyObject *value = 0;
1066     PyObject *traceback = 0;
1067     PyErr_Fetch(&type, &value, &traceback);
1068     if (value) {
1069       PyObject *old_str = PyObject_Str(value);
1070       Py_XINCREF(type);
1071       PyErr_Clear();
1072       if (infront) {
1073         PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074       } else {
1075         PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076       }
1077       Py_DECREF(old_str);
1078     }
1079     return 1;
1080   } else {
1081     return 0;
1082   }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088   if (PyErr_Occurred()) {
1089     /* add information about failing argument */
1090     char mesg[256];
1091     sprintf(mesg, "argument number %d:", argnum);
1092     return SWIG_Python_AddErrMesg(mesg, 1);
1093   } else {
1094     return 0;
1095   }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100  * pointers/data manipulation
1101  * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106   swig_type_info *tc;
1107   const char *c = 0;
1108   static PyObject *SWIG_this = 0;
1109   int    newref = 0;
1110   PyObject  *pyobj = 0;
1111   void *vptr;
1112
1113   if (!obj) return 0;
1114   if (obj == Py_None) {
1115     *ptr = 0;
1116     return 0;
1117   }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120   if (!(PySwigObject_Check(obj))) {
1121     if (!SWIG_this)
1122       SWIG_this = PyString_FromString("this");
1123     pyobj = obj;
1124     obj = PyObject_GetAttr(obj,SWIG_this);
1125     newref = 1;
1126     if (!obj) goto type_error;
1127     if (!PySwigObject_Check(obj)) {
1128       Py_DECREF(obj);
1129       goto type_error;
1130     }
1131   }
1132   vptr = PySwigObject_AsVoidPtr(obj);
1133   c = (const char *) PySwigObject_GetDesc(obj);
1134   if (newref) { Py_DECREF(obj); }
1135   goto type_check;
1136 #else
1137   if (!(PyString_Check(obj))) {
1138     if (!SWIG_this)
1139       SWIG_this = PyString_FromString("this");
1140     pyobj = obj;
1141     obj = PyObject_GetAttr(obj,SWIG_this);
1142     newref = 1;
1143     if (!obj) goto type_error;
1144     if (!PyString_Check(obj)) {
1145       Py_DECREF(obj);
1146       goto type_error;
1147     }
1148   }
1149   c = PyString_AS_STRING(obj);
1150   /* Pointer values must start with leading underscore */
1151   c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152   if (newref) { Py_DECREF(obj); }
1153   if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158   if (ty) {
1159     tc = SWIG_TypeCheck(c,ty);
1160     if (!tc) goto type_error;
1161     *ptr = SWIG_TypeCast(tc,vptr);
1162   } else {
1163     *ptr = vptr;
1164   }
1165
1166   if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167     PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168   }
1169   return 0;
1170
1171 type_error:
1172   PyErr_Clear();
1173   if (pyobj && !obj) {
1174     obj = pyobj;
1175     if (PyCFunction_Check(obj)) {
1176       /* here we get the method pointer for callbacks */
1177       char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178       c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179       if (c) {
1180         c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181         if (!c) goto type_error;
1182         goto type_check;
1183       }
1184     }
1185   }
1186   if (flags & SWIG_POINTER_EXCEPTION) {
1187     if (ty) {
1188       SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189     } else {
1190       SWIG_Python_TypeError("C/C++ pointer", obj);
1191     }
1192   }
1193   return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199   void *result;
1200   if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201     PyErr_Clear();
1202     if (flags & SWIG_POINTER_EXCEPTION) {
1203       SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204       SWIG_Python_ArgFail(argnum);
1205     }
1206   }
1207   return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213   swig_type_info *tc;
1214   const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217   c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219   if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220   c = PyString_AS_STRING(obj);
1221   /* Pointer values must start with leading underscore */
1222   c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224   if (!c) goto type_error;
1225   if (ty) {
1226     tc = SWIG_TypeCheck(c,ty);
1227     if (!tc) goto type_error;
1228   }
1229   return 0;
1230
1231 type_error:
1232   PyErr_Clear();
1233   if (flags & SWIG_POINTER_EXCEPTION) {
1234     if (ty) {
1235       SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236     } else {
1237       SWIG_Python_TypeError("C/C++ packed data", obj);
1238     }
1239   }
1240   return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246   PyObject *robj = 0;
1247   if (!ptr) {
1248     Py_INCREF(Py_None);
1249     return Py_None;
1250   }
1251 #ifdef SWIG_COBJECT_TYPES
1252   robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254   {
1255     char result[SWIG_BUFFER_SIZE];
1256     robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257       PyString_FromString(result) : 0;
1258   }
1259 #endif
1260   if (!robj || (robj == Py_None)) return robj;
1261   if (type->clientdata) {
1262     PyObject *inst;
1263     PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264     Py_DECREF(robj);
1265     inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266     Py_DECREF(args);
1267     if (inst) {
1268       if (own) {
1269         PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270       }
1271       robj = inst;
1272     }
1273   }
1274   return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279   PyObject *robj = 0;
1280   if (!ptr) {
1281     Py_INCREF(Py_None);
1282     return Py_None;
1283   }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285   robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287   {
1288     char result[SWIG_BUFFER_SIZE];
1289     robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290       PyString_FromString(result) : 0;
1291   }
1292 #endif
1293   return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297  *  Get type list
1298  * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306   static void *type_pointer = (void *)0;
1307   /* first check if module already created */
1308   if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310     type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312     type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313                                     (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314     if (PyErr_Occurred()) {
1315       PyErr_Clear();
1316       type_pointer = (void *)0;
1317     }
1318   }
1319 #endif
1320   return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324   Search for a swig_type_info structure
1325  */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328   swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329   return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define  SWIGTYPE_p_wxPostScriptDC swig_types[0]
1342 #define  SWIGTYPE_p_wxBrush swig_types[1]
1343 #define  SWIGTYPE_p_wxColour swig_types[2]
1344 #define  SWIGTYPE_p_wxDC swig_types[3]
1345 #define  SWIGTYPE_p_wxMirrorDC swig_types[4]
1346 #define  SWIGTYPE_p_form_ops_t swig_types[5]
1347 #define  SWIGTYPE_p_wxDuplexMode swig_types[6]
1348 #define  SWIGTYPE_p_wxPyFontEnumerator swig_types[7]
1349 #define  SWIGTYPE_p_char swig_types[8]
1350 #define  SWIGTYPE_p_wxIconLocation swig_types[9]
1351 #define  SWIGTYPE_p_wxImage swig_types[10]
1352 #define  SWIGTYPE_p_wxMetaFileDC swig_types[11]
1353 #define  SWIGTYPE_p_wxMask swig_types[12]
1354 #define  SWIGTYPE_p_wxSize swig_types[13]
1355 #define  SWIGTYPE_p_wxFont swig_types[14]
1356 #define  SWIGTYPE_p_wxWindow swig_types[15]
1357 #define  SWIGTYPE_p_double swig_types[16]
1358 #define  SWIGTYPE_p_wxMemoryDC swig_types[17]
1359 #define  SWIGTYPE_p_wxFontMapper swig_types[18]
1360 #define  SWIGTYPE_p_wxEffects swig_types[19]
1361 #define  SWIGTYPE_p_wxNativeEncodingInfo swig_types[20]
1362 #define  SWIGTYPE_p_wxPalette swig_types[21]
1363 #define  SWIGTYPE_p_wxBitmap swig_types[22]
1364 #define  SWIGTYPE_p_wxObject swig_types[23]
1365 #define  SWIGTYPE_p_wxRegionIterator swig_types[24]
1366 #define  SWIGTYPE_p_wxRect swig_types[25]
1367 #define  SWIGTYPE_p_wxPaperSize swig_types[26]
1368 #define  SWIGTYPE_p_wxString swig_types[27]
1369 #define  SWIGTYPE_unsigned_int swig_types[28]
1370 #define  SWIGTYPE_p_unsigned_int swig_types[29]
1371 #define  SWIGTYPE_p_wxPrinterDC swig_types[30]
1372 #define  SWIGTYPE_p_wxIconBundle swig_types[31]
1373 #define  SWIGTYPE_p_wxPoint swig_types[32]
1374 #define  SWIGTYPE_p_wxDash swig_types[33]
1375 #define  SWIGTYPE_p_wxScreenDC swig_types[34]
1376 #define  SWIGTYPE_p_wxCursor swig_types[35]
1377 #define  SWIGTYPE_p_wxClientDC swig_types[36]
1378 #define  SWIGTYPE_p_wxBufferedDC swig_types[37]
1379 #define  SWIGTYPE_p_wxImageList swig_types[38]
1380 #define  SWIGTYPE_p_unsigned_char swig_types[39]
1381 #define  SWIGTYPE_p_wxGDIObject swig_types[40]
1382 #define  SWIGTYPE_p_wxIcon swig_types[41]
1383 #define  SWIGTYPE_p_wxLocale swig_types[42]
1384 #define  SWIGTYPE_ptrdiff_t swig_types[43]
1385 #define  SWIGTYPE_std__ptrdiff_t swig_types[44]
1386 #define  SWIGTYPE_p_wxRegion swig_types[45]
1387 #define  SWIGTYPE_p_wxConfigBase swig_types[46]
1388 #define  SWIGTYPE_p_wxLanguageInfo swig_types[47]
1389 #define  SWIGTYPE_p_wxWindowDC swig_types[48]
1390 #define  SWIGTYPE_p_wxPrintData swig_types[49]
1391 #define  SWIGTYPE_p_wxBrushList swig_types[50]
1392 #define  SWIGTYPE_p_wxFontList swig_types[51]
1393 #define  SWIGTYPE_p_wxPen swig_types[52]
1394 #define  SWIGTYPE_p_wxBufferedPaintDC swig_types[53]
1395 #define  SWIGTYPE_p_wxPaintDC swig_types[54]
1396 #define  SWIGTYPE_p_wxPenList swig_types[55]
1397 #define  SWIGTYPE_p_int swig_types[56]
1398 #define  SWIGTYPE_p_wxMetaFile swig_types[57]
1399 #define  SWIGTYPE_p_unsigned_long swig_types[58]
1400 #define  SWIGTYPE_p_wxNativeFontInfo swig_types[59]
1401 #define  SWIGTYPE_p_wxEncodingConverter swig_types[60]
1402 #define  SWIGTYPE_p_wxColourDatabase swig_types[61]
1403 static swig_type_info *swig_types[63];
1404
1405 /* -------- TYPES TABLE (END) -------- */
1406
1407
1408 /*-----------------------------------------------
1409               @(target):= _gdi_.so
1410   ------------------------------------------------*/
1411 #define SWIG_init    init_gdi_
1412
1413 #define SWIG_name    "_gdi_"
1414
1415 #include "wx/wxPython/wxPython.h"
1416 #include "wx/wxPython/pyclasses.h"
1417
1418
1419  static const wxString wxPyEmptyString(wxEmptyString);
1420
1421 #include <limits.h>
1422
1423
1424 SWIGINTERN int
1425   SWIG_CheckLongInRange(long value, long min_value, long max_value,
1426                         const char *errmsg)
1427 {
1428   if (value < min_value) {
1429     if (errmsg) {
1430       PyErr_Format(PyExc_OverflowError,
1431                    "value %ld is less than '%s' minimum %ld",
1432                    value, errmsg, min_value);
1433     }
1434     return 0;
1435   } else if (value > max_value) {
1436     if (errmsg) {
1437       PyErr_Format(PyExc_OverflowError,
1438                    "value %ld is greater than '%s' maximum %ld",
1439                    value, errmsg, max_value);
1440     }
1441     return 0;
1442   }
1443   return 1;
1444 }
1445
1446
1447 SWIGINTERN int
1448 SWIG_AsVal_long(PyObject* obj, long* val)
1449 {
1450     if (PyNumber_Check(obj)) {
1451         if (val) *val = PyInt_AsLong(obj);
1452         return 1;
1453     }
1454     else {
1455         SWIG_type_error("number", obj);
1456     }
1457     return 0;
1458 }
1459
1460
1461 #if INT_MAX != LONG_MAX
1462 SWIGINTERN int
1463   SWIG_AsVal_int(PyObject *obj, int *val)
1464 {
1465   const char* errmsg = val ? "int" : (char*)0;
1466   long v;
1467   if (SWIG_AsVal_long(obj, &v)) {
1468     if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1469       if (val) *val = (int)(v);
1470       return 1;
1471     } else {
1472       return 0;
1473     }
1474   } else {
1475     PyErr_Clear();
1476   }
1477   if (val) {
1478     SWIG_type_error(errmsg, obj);
1479   }
1480   return 0;
1481 }
1482 #else
1483 SWIGINTERNSHORT int
1484   SWIG_AsVal_int(PyObject *obj, int *val)
1485 {
1486   return SWIG_AsVal_long(obj,(long*)val);
1487 }
1488 #endif
1489
1490
1491 SWIGINTERN int
1492   SWIG_AsVal_bool(PyObject *obj, bool *val)
1493 {
1494   if (obj == Py_True) {
1495     if (val) *val = true;
1496     return 1;
1497   }
1498   if (obj == Py_False) {
1499     if (val) *val = false;
1500     return 1;
1501   }
1502   int res = 0;
1503   if (SWIG_AsVal_int(obj, &res)) {
1504     if (val) *val = res ? true : false;
1505     return 1;
1506   } else {
1507     PyErr_Clear();
1508   }
1509   if (val) {
1510     SWIG_type_error("bool", obj);
1511   }
1512   return 0;
1513 }
1514
1515
1516 SWIGINTERNSHORT bool
1517 SWIG_As_bool(PyObject* obj)
1518 {
1519   bool v;
1520   if (!SWIG_AsVal_bool(obj, &v)) {
1521     /*
1522       this is needed to make valgrind/purify happier.
1523      */
1524     memset((void*)&v, 0, sizeof(bool));
1525   }
1526   return v;
1527 }
1528
1529
1530 SWIGINTERNSHORT int
1531 SWIG_Check_bool(PyObject* obj)
1532 {
1533   return SWIG_AsVal_bool(obj, (bool*)0);
1534 }
1535
1536
1537 SWIGINTERN int
1538 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1539 {
1540     long v = 0;
1541     if (SWIG_AsVal_long(obj, &v) && v < 0) {
1542         SWIG_type_error("unsigned number", obj);
1543     }
1544     else if (val)
1545         *val = (unsigned long)v;
1546     return 1;
1547 }
1548
1549
1550 SWIGINTERNSHORT int
1551   SWIG_CheckUnsignedLongInRange(unsigned long value,
1552                                 unsigned long max_value,
1553                                 const char *errmsg)
1554 {
1555   if (value > max_value) {
1556     if (errmsg) {
1557       PyErr_Format(PyExc_OverflowError,
1558                    "value %lu is greater than '%s' minimum %lu",
1559                    value, errmsg, max_value);
1560     }
1561     return 0;
1562   }
1563   return 1;
1564  }
1565
1566
1567 SWIGINTERN int
1568   SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
1569 {
1570   const char* errmsg = val ? "unsigned char" : (char*)0;
1571   unsigned long v;
1572   if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1573     if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
1574       if (val) *val = (unsigned char)(v);
1575       return 1;
1576     } else {
1577       return 0;
1578     }
1579   } else {
1580     PyErr_Clear();
1581   }
1582   if (val) {
1583     SWIG_type_error(errmsg, obj);
1584   }
1585   return 0;
1586 }
1587
1588
1589 SWIGINTERNSHORT unsigned char
1590 SWIG_As_unsigned_SS_char(PyObject* obj)
1591 {
1592   unsigned char v;
1593   if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
1594     /*
1595       this is needed to make valgrind/purify happier.
1596      */
1597     memset((void*)&v, 0, sizeof(unsigned char));
1598   }
1599   return v;
1600 }
1601
1602
1603 SWIGINTERNSHORT int
1604 SWIG_Check_unsigned_SS_char(PyObject* obj)
1605 {
1606   return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
1607 }
1608
1609
1610 SWIGINTERNSHORT unsigned long
1611 SWIG_As_unsigned_SS_long(PyObject* obj)
1612 {
1613   unsigned long v;
1614   if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1615     /*
1616       this is needed to make valgrind/purify happier.
1617      */
1618     memset((void*)&v, 0, sizeof(unsigned long));
1619   }
1620   return v;
1621 }
1622
1623
1624 SWIGINTERNSHORT int
1625 SWIG_Check_unsigned_SS_long(PyObject* obj)
1626 {
1627   return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1628 }
1629
1630
1631   /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1632 #define SWIG_From_unsigned_SS_char PyInt_FromLong
1633 /*@@*/
1634
1635
1636   /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1637 #define SWIG_From_long PyInt_FromLong
1638 /*@@*/
1639
1640 static PyObject *wxColour_Get(wxColour *self){
1641             PyObject* rv = PyTuple_New(3);
1642             int red = -1;
1643             int green = -1;
1644             int blue = -1;
1645             if (self->Ok()) {
1646                 red =   self->Red();
1647                 green = self->Green();
1648                 blue =  self->Blue();
1649             }
1650             PyTuple_SetItem(rv, 0, PyInt_FromLong(red));
1651             PyTuple_SetItem(rv, 1, PyInt_FromLong(green));
1652             PyTuple_SetItem(rv, 2, PyInt_FromLong(blue));
1653             return rv;
1654         }
1655 static unsigned long wxColour_GetRGB(wxColour *self){
1656             return self->Red() | (self->Green() << 8) | (self->Blue() << 16);
1657         }
1658
1659 SWIGINTERNSHORT PyObject*
1660   SWIG_From_unsigned_SS_long(unsigned long value)
1661 {
1662   return (value > LONG_MAX) ?
1663     PyLong_FromUnsignedLong(value)
1664     : PyInt_FromLong((long)(value));
1665 }
1666
1667
1668 SWIGINTERNSHORT int
1669 SWIG_As_int(PyObject* obj)
1670 {
1671   int v;
1672   if (!SWIG_AsVal_int(obj, &v)) {
1673     /*
1674       this is needed to make valgrind/purify happier.
1675      */
1676     memset((void*)&v, 0, sizeof(int));
1677   }
1678   return v;
1679 }
1680
1681
1682 SWIGINTERNSHORT int
1683 SWIG_Check_int(PyObject* obj)
1684 {
1685   return SWIG_AsVal_int(obj, (int*)0);
1686 }
1687
1688
1689   /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1690 #define SWIG_From_int PyInt_FromLong
1691 /*@@*/
1692
1693
1694   static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1695     PyObject*   o2;
1696     PyObject*   o3;
1697
1698     if (!target) {
1699         target = o;
1700     } else if (target == Py_None) {
1701         Py_DECREF(Py_None);
1702         target = o;
1703     } else {
1704         if (!PyTuple_Check(target)) {
1705             o2 = target;
1706             target = PyTuple_New(1);
1707             PyTuple_SetItem(target, 0, o2);
1708         }
1709         o3 = PyTuple_New(1);
1710         PyTuple_SetItem(o3, 0, o);
1711
1712         o2 = target;
1713         target = PySequence_Concat(o2, o3);
1714         Py_DECREF(o2);
1715         Py_DECREF(o3);
1716     }
1717     return target;
1718   }
1719
1720
1721 static PyObject *wxPen_GetDashes(wxPen *self){
1722             wxDash* dashes;
1723             int count = self->GetDashes(&dashes);
1724             wxPyBlock_t blocked = wxPyBeginBlockThreads();
1725             PyObject* retval = PyList_New(0);
1726             for (int x=0; x<count; x++) {
1727                 PyObject* pyint = PyInt_FromLong(dashes[x]);
1728                 PyList_Append(retval, pyint);
1729                 Py_DECREF(pyint);
1730             }
1731             wxPyEndBlockThreads(blocked);
1732             return retval;
1733         }
1734 static void wxPen__SetDashes(wxPen *self,PyObject *_self,PyObject *pyDashes){
1735             wxPyBlock_t blocked = wxPyBeginBlockThreads();
1736             int size = PyList_Size(pyDashes);
1737             wxDash* dashes = (wxDash*)byte_LIST_helper(pyDashes);
1738
1739             // black magic warning!  The array of wxDashes needs to exist as
1740             // long as the pen does because wxPen does not copy the array.  So
1741             // stick a copy in a Python string object and attach it to _self,
1742             // and then call SetDashes with a pointer to that array.  Then
1743             // when the Python pen object is destroyed the array will be
1744             // cleaned up too.
1745             PyObject* strDashes = PyString_FromStringAndSize((char*)dashes, size*sizeof(wxDash));
1746             PyObject_SetAttrString(_self, "_dashes", strDashes);
1747
1748             self->SetDashes(size, (wxDash*)PyString_AS_STRING(strDashes));
1749             delete [] dashes;
1750             Py_DECREF(strDashes);
1751             wxPyEndBlockThreads(blocked);
1752         }
1753 static bool wxPen___eq__(wxPen *self,wxPen const *other){ return other ? (*self == *other) : false; }
1754 static bool wxPen___ne__(wxPen *self,wxPen const *other){ return other ? (*self != *other) : true;  }
1755
1756 #include <wx/image.h>
1757
1758     static char** ConvertListOfStrings(PyObject* listOfStrings) {
1759         char**    cArray = NULL;
1760         int       count;
1761
1762         if (!PyList_Check(listOfStrings)) {
1763             PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
1764             return NULL;
1765         }
1766         count = PyList_Size(listOfStrings);
1767         cArray = new char*[count];
1768
1769         for(int x=0; x<count; x++) {
1770             // TODO: Need some validation and error checking here
1771             cArray[x] = PyString_AsString(PyList_GET_ITEM(listOfStrings, x));
1772         }
1773         return cArray;
1774     }
1775
1776
1777 static wxBitmap *new_wxBitmap(PyObject *listOfStrings){
1778             char**    cArray = NULL;
1779             wxBitmap* bmp;
1780
1781             cArray = ConvertListOfStrings(listOfStrings);
1782             if (! cArray)
1783                 return NULL;
1784             bmp = new wxBitmap(cArray);
1785             delete [] cArray;
1786             return bmp;
1787         }
1788 static wxBitmap *new_wxBitmap(PyObject *bits,int width,int height,int depth=1){
1789             char* buf;
1790             int   length;
1791             PyString_AsStringAndSize(bits, &buf, &length);
1792             return new wxBitmap(buf, width, height, depth);
1793         }
1794
1795 SWIGINTERNSHORT long
1796 SWIG_As_long(PyObject* obj)
1797 {
1798   long v;
1799   if (!SWIG_AsVal_long(obj, &v)) {
1800     /*
1801       this is needed to make valgrind/purify happier.
1802      */
1803     memset((void*)&v, 0, sizeof(long));
1804   }
1805   return v;
1806 }
1807
1808
1809 SWIGINTERNSHORT int
1810 SWIG_Check_long(PyObject* obj)
1811 {
1812   return SWIG_AsVal_long(obj, (long*)0);
1813 }
1814
1815 static void wxBitmap_SetHandle(wxBitmap *self,long handle){ self->SetHandle((WXHANDLE)handle); }
1816 static wxSize wxBitmap_GetSize(wxBitmap *self){
1817             wxSize size(self->GetWidth(), self->GetHeight());
1818             return size;
1819         }
1820 static void wxBitmap_SetMaskColour(wxBitmap *self,wxColour const &colour){
1821             wxMask *mask = new wxMask(*self, colour);
1822             self->SetMask(mask);
1823         }
1824 static void wxBitmap_SetSize(wxBitmap *self,wxSize const &size){
1825             self->SetWidth(size.x);
1826             self->SetHeight(size.y);
1827         }
1828 static bool wxBitmap___eq__(wxBitmap *self,wxBitmap const *other){ return other ? (*self == *other) : false; }
1829 static bool wxBitmap___ne__(wxBitmap *self,wxBitmap const *other){ return other ? (*self != *other) : true;  }
1830 static wxMask *new_wxMask(wxBitmap const &bitmap,wxColour const &colour=wxNullColour){
1831             if ( !colour.Ok() )
1832                 return new wxMask(bitmap, *wxBLACK);
1833             else
1834                 return new wxMask(bitmap, colour);
1835         }
1836
1837 #include <wx/iconbndl.h>
1838
1839 static wxIcon *new_wxIcon(wxBitmap const &bmp){
1840             wxIcon* icon = new wxIcon();
1841             icon->CopyFromBitmap(bmp);
1842             return icon;
1843         }
1844 static wxIcon *new_wxIcon(PyObject *listOfStrings){
1845             char**  cArray = NULL;
1846             wxIcon* icon;
1847
1848             cArray = ConvertListOfStrings(listOfStrings);
1849             if (! cArray)
1850                 return NULL;
1851             icon = new wxIcon(cArray);
1852             delete [] cArray;
1853             return icon;
1854         }
1855 static void wxIcon_SetHandle(wxIcon *self,long handle){ self->SetHandle((WXHANDLE)handle); }
1856 static wxIconLocation *new_wxIconLocation(wxString const *filename=&wxPyEmptyString,int num=0){
1857
1858             return new wxIconLocation(*filename, num);
1859
1860
1861
1862         }
1863 static void wxIconLocation_SetIndex(wxIconLocation *self,int num){
1864
1865             self->SetIndex(num);
1866
1867
1868
1869         }
1870 static int wxIconLocation_GetIndex(wxIconLocation *self){
1871
1872             return self->GetIndex();
1873
1874
1875
1876         }
1877 static wxCursor *new_wxCursor(wxString const &cursorName,long type,int hotSpotX=0,int hotSpotY=0){
1878 #ifdef __WXGTK__
1879             wxImage img(cursorName, type);
1880             img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, hotSpotX);
1881             img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, hotSpotY);
1882             return new wxCursor(img);
1883 #else
1884             return new wxCursor(cursorName, type, hotSpotX, hotSpotY);
1885 #endif
1886         }
1887 static void wxCursor_SetHandle(wxCursor *self,long handle){ self->SetHandle((WXHANDLE)handle); }
1888
1889
1890 static void wxRegionIterator_Next(wxRegionIterator *self){
1891             (*self) ++;
1892         }
1893 static bool wxRegionIterator___nonzero__(wxRegionIterator *self){
1894             return self->operator bool();
1895         }
1896
1897 #include <wx/fontutil.h>
1898 #include <wx/fontmap.h>
1899 #include <wx/fontenum.h>
1900
1901 static wxString wxNativeFontInfo___str__(wxNativeFontInfo *self){
1902             return self->ToString();
1903         }
1904
1905     wxNativeEncodingInfo* wxGetNativeFontEncoding(wxFontEncoding encoding)
1906         { wxPyRaiseNotImplemented(); return NULL; }
1907
1908     bool wxTestFontEncoding(const wxNativeEncodingInfo& info)
1909         { wxPyRaiseNotImplemented(); return false; }
1910
1911 static PyObject *wxFontMapper_GetAltForEncoding(wxFontMapper *self,wxFontEncoding encoding,wxString const &facename=wxPyEmptyString,bool interactive=true){
1912             wxFontEncoding alt_enc;
1913             if (self->GetAltForEncoding(encoding, &alt_enc, facename, interactive))
1914                 return PyInt_FromLong(alt_enc);
1915             else {
1916                 Py_INCREF(Py_None);
1917                 return Py_None;
1918             }
1919         }
1920 static wxFont *new_wxFont(wxString const &info){
1921             wxNativeFontInfo nfi;
1922             nfi.FromString(info);
1923             return new wxFont(nfi);
1924         }
1925 static wxFont *new_wxFont(int pointSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxPyEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1926             return wxFont::New(pointSize, family, flags, face, encoding);
1927         }
1928 static wxFont *new_wxFont(wxSize const &pixelSize,int family,int style,int weight,bool underlined=false,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1929             return wxFontBase::New(pixelSize, family,
1930                                    style, weight, underlined,
1931                                    face, encoding);
1932         }
1933 static bool wxFont___eq__(wxFont *self,wxFont const *other){ return other ? (*self == *other) : false; }
1934 static bool wxFont___ne__(wxFont *self,wxFont const *other){ return other ? (*self != *other) : true;  }
1935
1936 class wxPyFontEnumerator : public wxFontEnumerator {
1937 public:
1938     wxPyFontEnumerator() {}
1939     ~wxPyFontEnumerator() {}
1940
1941     DEC_PYCALLBACK_BOOL_STRING(OnFacename);
1942     DEC_PYCALLBACK_BOOL_STRINGSTRING(OnFontEncoding);
1943
1944     PYPRIVATE;
1945 };
1946
1947 IMP_PYCALLBACK_BOOL_STRING(wxPyFontEnumerator, wxFontEnumerator, OnFacename);
1948 IMP_PYCALLBACK_BOOL_STRINGSTRING(wxPyFontEnumerator, wxFontEnumerator, OnFontEncoding);
1949
1950
1951 static PyObject *wxPyFontEnumerator_GetEncodings(wxPyFontEnumerator *self){
1952             wxArrayString* arr = self->GetEncodings();
1953             if (arr)
1954                 return wxArrayString2PyList_helper(*arr);
1955             else
1956                 return PyList_New(0);
1957         }
1958 static PyObject *wxPyFontEnumerator_GetFacenames(wxPyFontEnumerator *self){
1959             wxArrayString* arr = self->GetFacenames();
1960             if (arr)
1961                 return wxArrayString2PyList_helper(*arr);
1962             else
1963                 return PyList_New(0);
1964         }
1965
1966 #include <locale.h>
1967
1968 static wxLocale *new_wxLocale(int language=-1,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
1969             wxLocale* loc;
1970             if (language == -1)
1971                 loc = new wxLocale();
1972             else
1973                 loc = new wxLocale(language, flags);
1974             // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1975             // for the floating point conversions and such to work right.
1976 #if PY_VERSION_HEX < 0x02040000
1977             setlocale(LC_NUMERIC, "C");
1978 #endif
1979             return loc;
1980         }
1981 static bool wxLocale_Init1(wxLocale *self,wxString const &szName,wxString const &szShort=wxPyEmptyString,wxString const &szLocale=wxPyEmptyString,bool bLoadDefault=true,bool bConvertEncoding=false){
1982             bool rc = self->Init(szName, szShort, szLocale, bLoadDefault, bConvertEncoding);
1983             // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1984             // for the floating point conversions and such to work right.
1985 #if PY_VERSION_HEX < 0x02040000
1986             setlocale(LC_NUMERIC, "C");
1987 #endif
1988             return rc;
1989         }
1990 static bool wxLocale_Init2(wxLocale *self,int language=wxLANGUAGE_DEFAULT,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
1991             bool rc = self->Init(language, flags);
1992             // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1993             // for the floating point conversions and such to work right.
1994 #if PY_VERSION_HEX < 0x02040000
1995             setlocale(LC_NUMERIC, "C");
1996 #endif
1997             return rc;
1998         }
1999
2000 #include "wx/wxPython/pydrawxxx.h"
2001
2002 static wxColour wxDC_GetPixel(wxDC *self,int x,int y){
2003             wxColour col;
2004             self->GetPixel(x, y, &col);
2005             return col;
2006         }
2007 static wxColour wxDC_GetPixelPoint(wxDC *self,wxPoint const &pt){
2008             wxColour col;
2009             self->GetPixel(pt, &col);
2010             return col;
2011         }
2012
2013 SWIGINTERN int
2014 SWIG_AsVal_double(PyObject *obj, double* val)
2015 {
2016     if (PyNumber_Check(obj)) {
2017         if (val) *val = PyFloat_AsDouble(obj);
2018         return 1;
2019     }
2020     else {
2021         SWIG_type_error("number", obj);
2022     }
2023     return 0;
2024 }
2025
2026
2027 SWIGINTERNSHORT double
2028 SWIG_As_double(PyObject* obj)
2029 {
2030   double v;
2031   if (!SWIG_AsVal_double(obj, &v)) {
2032     /*
2033       this is needed to make valgrind/purify happier.
2034      */
2035     memset((void*)&v, 0, sizeof(double));
2036   }
2037   return v;
2038 }
2039
2040
2041 SWIGINTERNSHORT int
2042 SWIG_Check_double(PyObject* obj)
2043 {
2044   return SWIG_AsVal_double(obj, (double*)0);
2045 }
2046
2047 static wxRect wxDC_DrawImageLabel(wxDC *self,wxString const &text,wxBitmap const &image,wxRect const &rect,int alignment=wxALIGN_LEFT|wxALIGN_TOP,int indexAccel=-1){
2048             wxRect rv;
2049             self->DrawLabel(text, image, rect, alignment, indexAccel, &rv);
2050             return rv;
2051         }
2052
2053 static wxRect wxDC_GetClippingRect(wxDC *self){
2054             wxRect rect;
2055             self->GetClippingBox(rect);
2056             return rect;
2057         }
2058 static wxArrayInt wxDC_GetPartialTextExtents(wxDC *self,wxString const &text){
2059             wxArrayInt widths;
2060             self->GetPartialTextExtents(text, widths);
2061             return widths;
2062         }
2063
2064   /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2065 #define SWIG_From_double PyFloat_FromDouble
2066 /*@@*/
2067
2068
2069 static void wxDC_SetLogicalOriginPoint(wxDC *self,wxPoint const &point){
2070             self->SetLogicalOrigin(point.x, point.y);
2071         }
2072 static void wxDC_SetDeviceOriginPoint(wxDC *self,wxPoint const &point){
2073             self->SetDeviceOrigin(point.x, point.y);
2074         }
2075 static void wxDC_CalcBoundingBoxPoint(wxDC *self,wxPoint const &point){
2076             self->CalcBoundingBox(point.x, point.y);
2077         }
2078 static PyObject *wxDC__DrawPointList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2079             return wxPyDrawXXXList(*self, wxPyDrawXXXPoint, pyCoords, pyPens, pyBrushes);
2080         }
2081 static PyObject *wxDC__DrawLineList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2082             return wxPyDrawXXXList(*self, wxPyDrawXXXLine, pyCoords, pyPens, pyBrushes);
2083         }
2084 static PyObject *wxDC__DrawRectangleList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2085             return wxPyDrawXXXList(*self, wxPyDrawXXXRectangle, pyCoords, pyPens, pyBrushes);
2086         }
2087 static PyObject *wxDC__DrawEllipseList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2088             return wxPyDrawXXXList(*self, wxPyDrawXXXEllipse, pyCoords, pyPens, pyBrushes);
2089         }
2090 static PyObject *wxDC__DrawPolygonList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2091             return wxPyDrawXXXList(*self, wxPyDrawXXXPolygon, pyCoords, pyPens, pyBrushes);
2092         }
2093 static PyObject *wxDC__DrawTextList(wxDC *self,PyObject *textList,PyObject *pyPoints,PyObject *foregroundList,PyObject *backgroundList){
2094             return wxPyDrawTextList(*self, textList, pyPoints, foregroundList, backgroundList);
2095         }
2096
2097 static void wxDC_GetBoundingBox(wxDC* dc, int* x1, int* y1, int* x2, int* y2) {
2098     *x1 = dc->MinX();
2099     *y1 = dc->MinY();
2100     *x2 = dc->MaxX();
2101     *y2 = dc->MaxY();
2102 }
2103
2104
2105 #include <wx/dcbuffer.h>
2106
2107
2108 #include <wx/dcps.h>
2109
2110
2111 #include <wx/metafile.h>
2112
2113
2114
2115 static void wxColourDatabase_Append(wxColourDatabase *self,wxString const &name,int red,int green,int blue){
2116             self->AddColour(name, wxColour(red, green, blue));
2117         }
2118
2119 #include <wx/effects.h>
2120
2121 #ifdef __cplusplus
2122 extern "C" {
2123 #endif
2124 static PyObject *_wrap_new_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2125     PyObject *resultobj;
2126     wxGDIObject *result;
2127     char *kwnames[] = {
2128         NULL
2129     };
2130
2131     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GDIObject",kwnames)) goto fail;
2132     {
2133         if (!wxPyCheckForApp()) SWIG_fail;
2134         PyThreadState* __tstate = wxPyBeginAllowThreads();
2135         result = (wxGDIObject *)new wxGDIObject();
2136
2137         wxPyEndAllowThreads(__tstate);
2138         if (PyErr_Occurred()) SWIG_fail;
2139     }
2140     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGDIObject, 1);
2141     return resultobj;
2142     fail:
2143     return NULL;
2144 }
2145
2146
2147 static PyObject *_wrap_delete_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2148     PyObject *resultobj;
2149     wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2150     PyObject * obj0 = 0 ;
2151     char *kwnames[] = {
2152         (char *) "self", NULL
2153     };
2154
2155     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GDIObject",kwnames,&obj0)) goto fail;
2156     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2157     if (SWIG_arg_fail(1)) SWIG_fail;
2158     {
2159         PyThreadState* __tstate = wxPyBeginAllowThreads();
2160         delete arg1;
2161
2162         wxPyEndAllowThreads(__tstate);
2163         if (PyErr_Occurred()) SWIG_fail;
2164     }
2165     Py_INCREF(Py_None); resultobj = Py_None;
2166     return resultobj;
2167     fail:
2168     return NULL;
2169 }
2170
2171
2172 static PyObject *_wrap_GDIObject_GetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2173     PyObject *resultobj;
2174     wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2175     bool result;
2176     PyObject * obj0 = 0 ;
2177     char *kwnames[] = {
2178         (char *) "self", NULL
2179     };
2180
2181     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_GetVisible",kwnames,&obj0)) goto fail;
2182     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2183     if (SWIG_arg_fail(1)) SWIG_fail;
2184     {
2185         PyThreadState* __tstate = wxPyBeginAllowThreads();
2186         result = (bool)(arg1)->GetVisible();
2187
2188         wxPyEndAllowThreads(__tstate);
2189         if (PyErr_Occurred()) SWIG_fail;
2190     }
2191     {
2192         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2193     }
2194     return resultobj;
2195     fail:
2196     return NULL;
2197 }
2198
2199
2200 static PyObject *_wrap_GDIObject_SetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2201     PyObject *resultobj;
2202     wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2203     bool arg2 ;
2204     PyObject * obj0 = 0 ;
2205     PyObject * obj1 = 0 ;
2206     char *kwnames[] = {
2207         (char *) "self",(char *) "visible", NULL
2208     };
2209
2210     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GDIObject_SetVisible",kwnames,&obj0,&obj1)) goto fail;
2211     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2212     if (SWIG_arg_fail(1)) SWIG_fail;
2213     {
2214         arg2 = (bool)(SWIG_As_bool(obj1));
2215         if (SWIG_arg_fail(2)) SWIG_fail;
2216     }
2217     {
2218         PyThreadState* __tstate = wxPyBeginAllowThreads();
2219         (arg1)->SetVisible(arg2);
2220
2221         wxPyEndAllowThreads(__tstate);
2222         if (PyErr_Occurred()) SWIG_fail;
2223     }
2224     Py_INCREF(Py_None); resultobj = Py_None;
2225     return resultobj;
2226     fail:
2227     return NULL;
2228 }
2229
2230
2231 static PyObject *_wrap_GDIObject_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
2232     PyObject *resultobj;
2233     wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2234     bool result;
2235     PyObject * obj0 = 0 ;
2236     char *kwnames[] = {
2237         (char *) "self", NULL
2238     };
2239
2240     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_IsNull",kwnames,&obj0)) goto fail;
2241     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2242     if (SWIG_arg_fail(1)) SWIG_fail;
2243     {
2244         PyThreadState* __tstate = wxPyBeginAllowThreads();
2245         result = (bool)(arg1)->IsNull();
2246
2247         wxPyEndAllowThreads(__tstate);
2248         if (PyErr_Occurred()) SWIG_fail;
2249     }
2250     {
2251         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2252     }
2253     return resultobj;
2254     fail:
2255     return NULL;
2256 }
2257
2258
2259 static PyObject * GDIObject_swigregister(PyObject *, PyObject *args) {
2260     PyObject *obj;
2261     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2262     SWIG_TypeClientData(SWIGTYPE_p_wxGDIObject, obj);
2263     Py_INCREF(obj);
2264     return Py_BuildValue((char *)"");
2265 }
2266 static PyObject *_wrap_new_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2267     PyObject *resultobj;
2268     byte arg1 = (byte) 0 ;
2269     byte arg2 = (byte) 0 ;
2270     byte arg3 = (byte) 0 ;
2271     wxColour *result;
2272     PyObject * obj0 = 0 ;
2273     PyObject * obj1 = 0 ;
2274     PyObject * obj2 = 0 ;
2275     char *kwnames[] = {
2276         (char *) "red",(char *) "green",(char *) "blue", NULL
2277     };
2278
2279     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Colour",kwnames,&obj0,&obj1,&obj2)) goto fail;
2280     if (obj0) {
2281         {
2282             arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
2283             if (SWIG_arg_fail(1)) SWIG_fail;
2284         }
2285     }
2286     if (obj1) {
2287         {
2288             arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2289             if (SWIG_arg_fail(2)) SWIG_fail;
2290         }
2291     }
2292     if (obj2) {
2293         {
2294             arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2295             if (SWIG_arg_fail(3)) SWIG_fail;
2296         }
2297     }
2298     {
2299         PyThreadState* __tstate = wxPyBeginAllowThreads();
2300         result = (wxColour *)new wxColour(arg1,arg2,arg3);
2301
2302         wxPyEndAllowThreads(__tstate);
2303         if (PyErr_Occurred()) SWIG_fail;
2304     }
2305     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2306     return resultobj;
2307     fail:
2308     return NULL;
2309 }
2310
2311
2312 static PyObject *_wrap_new_NamedColour(PyObject *, PyObject *args, PyObject *kwargs) {
2313     PyObject *resultobj;
2314     wxString *arg1 = 0 ;
2315     wxColour *result;
2316     bool temp1 = false ;
2317     PyObject * obj0 = 0 ;
2318     char *kwnames[] = {
2319         (char *) "colorName", NULL
2320     };
2321
2322     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_NamedColour",kwnames,&obj0)) goto fail;
2323     {
2324         arg1 = wxString_in_helper(obj0);
2325         if (arg1 == NULL) SWIG_fail;
2326         temp1 = true;
2327     }
2328     {
2329         if (!wxPyCheckForApp()) SWIG_fail;
2330         PyThreadState* __tstate = wxPyBeginAllowThreads();
2331         result = (wxColour *)new wxColour((wxString const &)*arg1);
2332
2333         wxPyEndAllowThreads(__tstate);
2334         if (PyErr_Occurred()) SWIG_fail;
2335     }
2336     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2337     {
2338         if (temp1)
2339         delete arg1;
2340     }
2341     return resultobj;
2342     fail:
2343     {
2344         if (temp1)
2345         delete arg1;
2346     }
2347     return NULL;
2348 }
2349
2350
2351 static PyObject *_wrap_new_ColourRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2352     PyObject *resultobj;
2353     unsigned long arg1 ;
2354     wxColour *result;
2355     PyObject * obj0 = 0 ;
2356     char *kwnames[] = {
2357         (char *) "colRGB", NULL
2358     };
2359
2360     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ColourRGB",kwnames,&obj0)) goto fail;
2361     {
2362         arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
2363         if (SWIG_arg_fail(1)) SWIG_fail;
2364     }
2365     {
2366         PyThreadState* __tstate = wxPyBeginAllowThreads();
2367         result = (wxColour *)new wxColour(arg1);
2368
2369         wxPyEndAllowThreads(__tstate);
2370         if (PyErr_Occurred()) SWIG_fail;
2371     }
2372     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2373     return resultobj;
2374     fail:
2375     return NULL;
2376 }
2377
2378
2379 static PyObject *_wrap_delete_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2380     PyObject *resultobj;
2381     wxColour *arg1 = (wxColour *) 0 ;
2382     PyObject * obj0 = 0 ;
2383     char *kwnames[] = {
2384         (char *) "self", NULL
2385     };
2386
2387     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Colour",kwnames,&obj0)) goto fail;
2388     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2389     if (SWIG_arg_fail(1)) SWIG_fail;
2390     {
2391         PyThreadState* __tstate = wxPyBeginAllowThreads();
2392         delete arg1;
2393
2394         wxPyEndAllowThreads(__tstate);
2395         if (PyErr_Occurred()) SWIG_fail;
2396     }
2397     Py_INCREF(Py_None); resultobj = Py_None;
2398     return resultobj;
2399     fail:
2400     return NULL;
2401 }
2402
2403
2404 static PyObject *_wrap_Colour_Red(PyObject *, PyObject *args, PyObject *kwargs) {
2405     PyObject *resultobj;
2406     wxColour *arg1 = (wxColour *) 0 ;
2407     byte result;
2408     PyObject * obj0 = 0 ;
2409     char *kwnames[] = {
2410         (char *) "self", NULL
2411     };
2412
2413     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Red",kwnames,&obj0)) goto fail;
2414     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2415     if (SWIG_arg_fail(1)) SWIG_fail;
2416     {
2417         PyThreadState* __tstate = wxPyBeginAllowThreads();
2418         result = (byte)(arg1)->Red();
2419
2420         wxPyEndAllowThreads(__tstate);
2421         if (PyErr_Occurred()) SWIG_fail;
2422     }
2423     {
2424         resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2425     }
2426     return resultobj;
2427     fail:
2428     return NULL;
2429 }
2430
2431
2432 static PyObject *_wrap_Colour_Green(PyObject *, PyObject *args, PyObject *kwargs) {
2433     PyObject *resultobj;
2434     wxColour *arg1 = (wxColour *) 0 ;
2435     byte result;
2436     PyObject * obj0 = 0 ;
2437     char *kwnames[] = {
2438         (char *) "self", NULL
2439     };
2440
2441     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Green",kwnames,&obj0)) goto fail;
2442     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2443     if (SWIG_arg_fail(1)) SWIG_fail;
2444     {
2445         PyThreadState* __tstate = wxPyBeginAllowThreads();
2446         result = (byte)(arg1)->Green();
2447
2448         wxPyEndAllowThreads(__tstate);
2449         if (PyErr_Occurred()) SWIG_fail;
2450     }
2451     {
2452         resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2453     }
2454     return resultobj;
2455     fail:
2456     return NULL;
2457 }
2458
2459
2460 static PyObject *_wrap_Colour_Blue(PyObject *, PyObject *args, PyObject *kwargs) {
2461     PyObject *resultobj;
2462     wxColour *arg1 = (wxColour *) 0 ;
2463     byte result;
2464     PyObject * obj0 = 0 ;
2465     char *kwnames[] = {
2466         (char *) "self", NULL
2467     };
2468
2469     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Blue",kwnames,&obj0)) goto fail;
2470     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2471     if (SWIG_arg_fail(1)) SWIG_fail;
2472     {
2473         PyThreadState* __tstate = wxPyBeginAllowThreads();
2474         result = (byte)(arg1)->Blue();
2475
2476         wxPyEndAllowThreads(__tstate);
2477         if (PyErr_Occurred()) SWIG_fail;
2478     }
2479     {
2480         resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2481     }
2482     return resultobj;
2483     fail:
2484     return NULL;
2485 }
2486
2487
2488 static PyObject *_wrap_Colour_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
2489     PyObject *resultobj;
2490     wxColour *arg1 = (wxColour *) 0 ;
2491     bool result;
2492     PyObject * obj0 = 0 ;
2493     char *kwnames[] = {
2494         (char *) "self", NULL
2495     };
2496
2497     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Ok",kwnames,&obj0)) goto fail;
2498     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2499     if (SWIG_arg_fail(1)) SWIG_fail;
2500     {
2501         PyThreadState* __tstate = wxPyBeginAllowThreads();
2502         result = (bool)(arg1)->Ok();
2503
2504         wxPyEndAllowThreads(__tstate);
2505         if (PyErr_Occurred()) SWIG_fail;
2506     }
2507     {
2508         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2509     }
2510     return resultobj;
2511     fail:
2512     return NULL;
2513 }
2514
2515
2516 static PyObject *_wrap_Colour_Set(PyObject *, PyObject *args, PyObject *kwargs) {
2517     PyObject *resultobj;
2518     wxColour *arg1 = (wxColour *) 0 ;
2519     byte arg2 ;
2520     byte arg3 ;
2521     byte arg4 ;
2522     PyObject * obj0 = 0 ;
2523     PyObject * obj1 = 0 ;
2524     PyObject * obj2 = 0 ;
2525     PyObject * obj3 = 0 ;
2526     char *kwnames[] = {
2527         (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2528     };
2529
2530     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Colour_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2531     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2532     if (SWIG_arg_fail(1)) SWIG_fail;
2533     {
2534         arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2535         if (SWIG_arg_fail(2)) SWIG_fail;
2536     }
2537     {
2538         arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2539         if (SWIG_arg_fail(3)) SWIG_fail;
2540     }
2541     {
2542         arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2543         if (SWIG_arg_fail(4)) SWIG_fail;
2544     }
2545     {
2546         PyThreadState* __tstate = wxPyBeginAllowThreads();
2547         (arg1)->Set(arg2,arg3,arg4);
2548
2549         wxPyEndAllowThreads(__tstate);
2550         if (PyErr_Occurred()) SWIG_fail;
2551     }
2552     Py_INCREF(Py_None); resultobj = Py_None;
2553     return resultobj;
2554     fail:
2555     return NULL;
2556 }
2557
2558
2559 static PyObject *_wrap_Colour_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2560     PyObject *resultobj;
2561     wxColour *arg1 = (wxColour *) 0 ;
2562     unsigned long arg2 ;
2563     PyObject * obj0 = 0 ;
2564     PyObject * obj1 = 0 ;
2565     char *kwnames[] = {
2566         (char *) "self",(char *) "colRGB", NULL
2567     };
2568
2569     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetRGB",kwnames,&obj0,&obj1)) goto fail;
2570     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2571     if (SWIG_arg_fail(1)) SWIG_fail;
2572     {
2573         arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
2574         if (SWIG_arg_fail(2)) SWIG_fail;
2575     }
2576     {
2577         PyThreadState* __tstate = wxPyBeginAllowThreads();
2578         (arg1)->Set(arg2);
2579
2580         wxPyEndAllowThreads(__tstate);
2581         if (PyErr_Occurred()) SWIG_fail;
2582     }
2583     Py_INCREF(Py_None); resultobj = Py_None;
2584     return resultobj;
2585     fail:
2586     return NULL;
2587 }
2588
2589
2590 static PyObject *_wrap_Colour_SetFromName(PyObject *, PyObject *args, PyObject *kwargs) {
2591     PyObject *resultobj;
2592     wxColour *arg1 = (wxColour *) 0 ;
2593     wxString *arg2 = 0 ;
2594     bool temp2 = false ;
2595     PyObject * obj0 = 0 ;
2596     PyObject * obj1 = 0 ;
2597     char *kwnames[] = {
2598         (char *) "self",(char *) "colourName", NULL
2599     };
2600
2601     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetFromName",kwnames,&obj0,&obj1)) goto fail;
2602     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2603     if (SWIG_arg_fail(1)) SWIG_fail;
2604     {
2605         arg2 = wxString_in_helper(obj1);
2606         if (arg2 == NULL) SWIG_fail;
2607         temp2 = true;
2608     }
2609     {
2610         PyThreadState* __tstate = wxPyBeginAllowThreads();
2611         (arg1)->InitFromName((wxString const &)*arg2);
2612
2613         wxPyEndAllowThreads(__tstate);
2614         if (PyErr_Occurred()) SWIG_fail;
2615     }
2616     Py_INCREF(Py_None); resultobj = Py_None;
2617     {
2618         if (temp2)
2619         delete arg2;
2620     }
2621     return resultobj;
2622     fail:
2623     {
2624         if (temp2)
2625         delete arg2;
2626     }
2627     return NULL;
2628 }
2629
2630
2631 static PyObject *_wrap_Colour_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2632     PyObject *resultobj;
2633     wxColour *arg1 = (wxColour *) 0 ;
2634     long result;
2635     PyObject * obj0 = 0 ;
2636     char *kwnames[] = {
2637         (char *) "self", NULL
2638     };
2639
2640     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetPixel",kwnames,&obj0)) goto fail;
2641     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2642     if (SWIG_arg_fail(1)) SWIG_fail;
2643     {
2644         PyThreadState* __tstate = wxPyBeginAllowThreads();
2645         result = (long)((wxColour const *)arg1)->GetPixel();
2646
2647         wxPyEndAllowThreads(__tstate);
2648         if (PyErr_Occurred()) SWIG_fail;
2649     }
2650     {
2651         resultobj = SWIG_From_long((long)(result));
2652     }
2653     return resultobj;
2654     fail:
2655     return NULL;
2656 }
2657
2658
2659 static PyObject *_wrap_Colour___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
2660     PyObject *resultobj;
2661     wxColour *arg1 = (wxColour *) 0 ;
2662     wxColour *arg2 = 0 ;
2663     bool result;
2664     wxColour temp2 ;
2665     PyObject * obj0 = 0 ;
2666     PyObject * obj1 = 0 ;
2667     char *kwnames[] = {
2668         (char *) "self",(char *) "colour", NULL
2669     };
2670
2671     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___eq__",kwnames,&obj0,&obj1)) goto fail;
2672     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2673     if (SWIG_arg_fail(1)) SWIG_fail;
2674     {
2675         arg2 = &temp2;
2676         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2677     }
2678     {
2679         PyThreadState* __tstate = wxPyBeginAllowThreads();
2680         result = (bool)((wxColour const *)arg1)->operator ==((wxColour const &)*arg2);
2681
2682         wxPyEndAllowThreads(__tstate);
2683         if (PyErr_Occurred()) SWIG_fail;
2684     }
2685     {
2686         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2687     }
2688     return resultobj;
2689     fail:
2690     return NULL;
2691 }
2692
2693
2694 static PyObject *_wrap_Colour___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
2695     PyObject *resultobj;
2696     wxColour *arg1 = (wxColour *) 0 ;
2697     wxColour *arg2 = 0 ;
2698     bool result;
2699     wxColour temp2 ;
2700     PyObject * obj0 = 0 ;
2701     PyObject * obj1 = 0 ;
2702     char *kwnames[] = {
2703         (char *) "self",(char *) "colour", NULL
2704     };
2705
2706     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___ne__",kwnames,&obj0,&obj1)) goto fail;
2707     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2708     if (SWIG_arg_fail(1)) SWIG_fail;
2709     {
2710         arg2 = &temp2;
2711         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2712     }
2713     {
2714         PyThreadState* __tstate = wxPyBeginAllowThreads();
2715         result = (bool)((wxColour const *)arg1)->operator !=((wxColour const &)*arg2);
2716
2717         wxPyEndAllowThreads(__tstate);
2718         if (PyErr_Occurred()) SWIG_fail;
2719     }
2720     {
2721         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2722     }
2723     return resultobj;
2724     fail:
2725     return NULL;
2726 }
2727
2728
2729 static PyObject *_wrap_Colour_Get(PyObject *, PyObject *args, PyObject *kwargs) {
2730     PyObject *resultobj;
2731     wxColour *arg1 = (wxColour *) 0 ;
2732     PyObject *result;
2733     PyObject * obj0 = 0 ;
2734     char *kwnames[] = {
2735         (char *) "self", NULL
2736     };
2737
2738     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Get",kwnames,&obj0)) goto fail;
2739     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2740     if (SWIG_arg_fail(1)) SWIG_fail;
2741     {
2742         PyThreadState* __tstate = wxPyBeginAllowThreads();
2743         result = (PyObject *)wxColour_Get(arg1);
2744
2745         wxPyEndAllowThreads(__tstate);
2746         if (PyErr_Occurred()) SWIG_fail;
2747     }
2748     resultobj = result;
2749     return resultobj;
2750     fail:
2751     return NULL;
2752 }
2753
2754
2755 static PyObject *_wrap_Colour_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2756     PyObject *resultobj;
2757     wxColour *arg1 = (wxColour *) 0 ;
2758     unsigned long result;
2759     PyObject * obj0 = 0 ;
2760     char *kwnames[] = {
2761         (char *) "self", NULL
2762     };
2763
2764     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetRGB",kwnames,&obj0)) goto fail;
2765     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2766     if (SWIG_arg_fail(1)) SWIG_fail;
2767     {
2768         PyThreadState* __tstate = wxPyBeginAllowThreads();
2769         result = (unsigned long)wxColour_GetRGB(arg1);
2770
2771         wxPyEndAllowThreads(__tstate);
2772         if (PyErr_Occurred()) SWIG_fail;
2773     }
2774     {
2775         resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
2776     }
2777     return resultobj;
2778     fail:
2779     return NULL;
2780 }
2781
2782
2783 static PyObject * Colour_swigregister(PyObject *, PyObject *args) {
2784     PyObject *obj;
2785     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2786     SWIG_TypeClientData(SWIGTYPE_p_wxColour, obj);
2787     Py_INCREF(obj);
2788     return Py_BuildValue((char *)"");
2789 }
2790 static PyObject *_wrap_new_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2791     PyObject *resultobj;
2792     int arg1 ;
2793     unsigned char *arg2 = (unsigned char *) 0 ;
2794     unsigned char *arg3 = (unsigned char *) 0 ;
2795     unsigned char *arg4 = (unsigned char *) 0 ;
2796     wxPalette *result;
2797     PyObject * obj0 = 0 ;
2798     PyObject * obj1 = 0 ;
2799     PyObject * obj2 = 0 ;
2800     PyObject * obj3 = 0 ;
2801     char *kwnames[] = {
2802         (char *) "n",(char *) "red",(char *) "green",(char *) "blue", NULL
2803     };
2804
2805     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_Palette",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2806     {
2807         arg1 = (int)(SWIG_As_int(obj0));
2808         if (SWIG_arg_fail(1)) SWIG_fail;
2809     }
2810     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2811     if (SWIG_arg_fail(2)) SWIG_fail;
2812     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2813     if (SWIG_arg_fail(3)) SWIG_fail;
2814     SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2815     if (SWIG_arg_fail(4)) SWIG_fail;
2816     {
2817         if (!wxPyCheckForApp()) SWIG_fail;
2818         PyThreadState* __tstate = wxPyBeginAllowThreads();
2819         result = (wxPalette *)new wxPalette(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
2820
2821         wxPyEndAllowThreads(__tstate);
2822         if (PyErr_Occurred()) SWIG_fail;
2823     }
2824     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 1);
2825     return resultobj;
2826     fail:
2827     return NULL;
2828 }
2829
2830
2831 static PyObject *_wrap_delete_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2832     PyObject *resultobj;
2833     wxPalette *arg1 = (wxPalette *) 0 ;
2834     PyObject * obj0 = 0 ;
2835     char *kwnames[] = {
2836         (char *) "self", NULL
2837     };
2838
2839     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Palette",kwnames,&obj0)) goto fail;
2840     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2841     if (SWIG_arg_fail(1)) SWIG_fail;
2842     {
2843         PyThreadState* __tstate = wxPyBeginAllowThreads();
2844         delete arg1;
2845
2846         wxPyEndAllowThreads(__tstate);
2847         if (PyErr_Occurred()) SWIG_fail;
2848     }
2849     Py_INCREF(Py_None); resultobj = Py_None;
2850     return resultobj;
2851     fail:
2852     return NULL;
2853 }
2854
2855
2856 static PyObject *_wrap_Palette_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2857     PyObject *resultobj;
2858     wxPalette *arg1 = (wxPalette *) 0 ;
2859     byte arg2 ;
2860     byte arg3 ;
2861     byte arg4 ;
2862     int result;
2863     PyObject * obj0 = 0 ;
2864     PyObject * obj1 = 0 ;
2865     PyObject * obj2 = 0 ;
2866     PyObject * obj3 = 0 ;
2867     char *kwnames[] = {
2868         (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2869     };
2870
2871     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Palette_GetPixel",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2872     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2873     if (SWIG_arg_fail(1)) SWIG_fail;
2874     {
2875         arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2876         if (SWIG_arg_fail(2)) SWIG_fail;
2877     }
2878     {
2879         arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2880         if (SWIG_arg_fail(3)) SWIG_fail;
2881     }
2882     {
2883         arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2884         if (SWIG_arg_fail(4)) SWIG_fail;
2885     }
2886     {
2887         PyThreadState* __tstate = wxPyBeginAllowThreads();
2888         result = (int)(arg1)->GetPixel(arg2,arg3,arg4);
2889
2890         wxPyEndAllowThreads(__tstate);
2891         if (PyErr_Occurred()) SWIG_fail;
2892     }
2893     {
2894         resultobj = SWIG_From_int((int)(result));
2895     }
2896     return resultobj;
2897     fail:
2898     return NULL;
2899 }
2900
2901
2902 static PyObject *_wrap_Palette_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2903     PyObject *resultobj;
2904     wxPalette *arg1 = (wxPalette *) 0 ;
2905     int arg2 ;
2906     byte *arg3 = (byte *) 0 ;
2907     byte *arg4 = (byte *) 0 ;
2908     byte *arg5 = (byte *) 0 ;
2909     bool result;
2910     byte temp3 ;
2911     int res3 = 0 ;
2912     byte temp4 ;
2913     int res4 = 0 ;
2914     byte temp5 ;
2915     int res5 = 0 ;
2916     PyObject * obj0 = 0 ;
2917     PyObject * obj1 = 0 ;
2918     char *kwnames[] = {
2919         (char *) "self",(char *) "pixel", NULL
2920     };
2921
2922     arg3 = &temp3; res3 = SWIG_NEWOBJ;
2923     arg4 = &temp4; res4 = SWIG_NEWOBJ;
2924     arg5 = &temp5; res5 = SWIG_NEWOBJ;
2925     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Palette_GetRGB",kwnames,&obj0,&obj1)) goto fail;
2926     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2927     if (SWIG_arg_fail(1)) SWIG_fail;
2928     {
2929         arg2 = (int)(SWIG_As_int(obj1));
2930         if (SWIG_arg_fail(2)) SWIG_fail;
2931     }
2932     {
2933         PyThreadState* __tstate = wxPyBeginAllowThreads();
2934         result = (bool)(arg1)->GetRGB(arg2,arg3,arg4,arg5);
2935
2936         wxPyEndAllowThreads(__tstate);
2937         if (PyErr_Occurred()) SWIG_fail;
2938     }
2939     {
2940         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2941     }
2942     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
2943     SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
2944     resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
2945     SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
2946     resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
2947     SWIG_From_unsigned_SS_char((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_unsigned_char, 0)));
2948     return resultobj;
2949     fail:
2950     return NULL;
2951 }
2952
2953
2954 static PyObject *_wrap_Palette_GetColoursCount(PyObject *, PyObject *args, PyObject *kwargs) {
2955     PyObject *resultobj;
2956     wxPalette *arg1 = (wxPalette *) 0 ;
2957     int result;
2958     PyObject * obj0 = 0 ;
2959     char *kwnames[] = {
2960         (char *) "self", NULL
2961     };
2962
2963     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_GetColoursCount",kwnames,&obj0)) goto fail;
2964     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2965     if (SWIG_arg_fail(1)) SWIG_fail;
2966     {
2967         PyThreadState* __tstate = wxPyBeginAllowThreads();
2968         result = (int)((wxPalette const *)arg1)->GetColoursCount();
2969
2970         wxPyEndAllowThreads(__tstate);
2971         if (PyErr_Occurred()) SWIG_fail;
2972     }
2973     {
2974         resultobj = SWIG_From_int((int)(result));
2975     }
2976     return resultobj;
2977     fail:
2978     return NULL;
2979 }
2980
2981
2982 static PyObject *_wrap_Palette_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
2983     PyObject *resultobj;
2984     wxPalette *arg1 = (wxPalette *) 0 ;
2985     bool result;
2986     PyObject * obj0 = 0 ;
2987     char *kwnames[] = {
2988         (char *) "self", NULL
2989     };
2990
2991     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_Ok",kwnames,&obj0)) goto fail;
2992     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2993     if (SWIG_arg_fail(1)) SWIG_fail;
2994     {
2995         PyThreadState* __tstate = wxPyBeginAllowThreads();
2996         result = (bool)(arg1)->Ok();
2997
2998         wxPyEndAllowThreads(__tstate);
2999         if (PyErr_Occurred()) SWIG_fail;
3000     }
3001     {
3002         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3003     }
3004     return resultobj;
3005     fail:
3006     return NULL;
3007 }
3008
3009
3010 static PyObject * Palette_swigregister(PyObject *, PyObject *args) {
3011     PyObject *obj;
3012     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3013     SWIG_TypeClientData(SWIGTYPE_p_wxPalette, obj);
3014     Py_INCREF(obj);
3015     return Py_BuildValue((char *)"");
3016 }
3017 static PyObject *_wrap_new_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3018     PyObject *resultobj;
3019     wxColour *arg1 = 0 ;
3020     int arg2 = (int) 1 ;
3021     int arg3 = (int) wxSOLID ;
3022     wxPen *result;
3023     wxColour temp1 ;
3024     PyObject * obj0 = 0 ;
3025     PyObject * obj1 = 0 ;
3026     PyObject * obj2 = 0 ;
3027     char *kwnames[] = {
3028         (char *) "colour",(char *) "width",(char *) "style", NULL
3029     };
3030
3031     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Pen",kwnames,&obj0,&obj1,&obj2)) goto fail;
3032     {
3033         arg1 = &temp1;
3034         if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3035     }
3036     if (obj1) {
3037         {
3038             arg2 = (int)(SWIG_As_int(obj1));
3039             if (SWIG_arg_fail(2)) SWIG_fail;
3040         }
3041     }
3042     if (obj2) {
3043         {
3044             arg3 = (int)(SWIG_As_int(obj2));
3045             if (SWIG_arg_fail(3)) SWIG_fail;
3046         }
3047     }
3048     {
3049         if (!wxPyCheckForApp()) SWIG_fail;
3050         PyThreadState* __tstate = wxPyBeginAllowThreads();
3051         result = (wxPen *)new wxPen(*arg1,arg2,arg3);
3052
3053         wxPyEndAllowThreads(__tstate);
3054         if (PyErr_Occurred()) SWIG_fail;
3055     }
3056     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 1);
3057     return resultobj;
3058     fail:
3059     return NULL;
3060 }
3061
3062
3063 static PyObject *_wrap_delete_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3064     PyObject *resultobj;
3065     wxPen *arg1 = (wxPen *) 0 ;
3066     PyObject * obj0 = 0 ;
3067     char *kwnames[] = {
3068         (char *) "self", NULL
3069     };
3070
3071     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Pen",kwnames,&obj0)) goto fail;
3072     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3073     if (SWIG_arg_fail(1)) SWIG_fail;
3074     {
3075         PyThreadState* __tstate = wxPyBeginAllowThreads();
3076         delete arg1;
3077
3078         wxPyEndAllowThreads(__tstate);
3079         if (PyErr_Occurred()) SWIG_fail;
3080     }
3081     Py_INCREF(Py_None); resultobj = Py_None;
3082     return resultobj;
3083     fail:
3084     return NULL;
3085 }
3086
3087
3088 static PyObject *_wrap_Pen_GetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3089     PyObject *resultobj;
3090     wxPen *arg1 = (wxPen *) 0 ;
3091     int result;
3092     PyObject * obj0 = 0 ;
3093     char *kwnames[] = {
3094         (char *) "self", NULL
3095     };
3096
3097     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetCap",kwnames,&obj0)) goto fail;
3098     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3099     if (SWIG_arg_fail(1)) SWIG_fail;
3100     {
3101         PyThreadState* __tstate = wxPyBeginAllowThreads();
3102         result = (int)(arg1)->GetCap();
3103
3104         wxPyEndAllowThreads(__tstate);
3105         if (PyErr_Occurred()) SWIG_fail;
3106     }
3107     {
3108         resultobj = SWIG_From_int((int)(result));
3109     }
3110     return resultobj;
3111     fail:
3112     return NULL;
3113 }
3114
3115
3116 static PyObject *_wrap_Pen_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3117     PyObject *resultobj;
3118     wxPen *arg1 = (wxPen *) 0 ;
3119     wxColour result;
3120     PyObject * obj0 = 0 ;
3121     char *kwnames[] = {
3122         (char *) "self", NULL
3123     };
3124
3125     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetColour",kwnames,&obj0)) goto fail;
3126     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3127     if (SWIG_arg_fail(1)) SWIG_fail;
3128     {
3129         PyThreadState* __tstate = wxPyBeginAllowThreads();
3130         result = (arg1)->GetColour();
3131
3132         wxPyEndAllowThreads(__tstate);
3133         if (PyErr_Occurred()) SWIG_fail;
3134     }
3135     {
3136         wxColour * resultptr;
3137         resultptr = new wxColour((wxColour &)(result));
3138         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3139     }
3140     return resultobj;
3141     fail:
3142     return NULL;
3143 }
3144
3145
3146 static PyObject *_wrap_Pen_GetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3147     PyObject *resultobj;
3148     wxPen *arg1 = (wxPen *) 0 ;
3149     int result;
3150     PyObject * obj0 = 0 ;
3151     char *kwnames[] = {
3152         (char *) "self", NULL
3153     };
3154
3155     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetJoin",kwnames,&obj0)) goto fail;
3156     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3157     if (SWIG_arg_fail(1)) SWIG_fail;
3158     {
3159         PyThreadState* __tstate = wxPyBeginAllowThreads();
3160         result = (int)(arg1)->GetJoin();
3161
3162         wxPyEndAllowThreads(__tstate);
3163         if (PyErr_Occurred()) SWIG_fail;
3164     }
3165     {
3166         resultobj = SWIG_From_int((int)(result));
3167     }
3168     return resultobj;
3169     fail:
3170     return NULL;
3171 }
3172
3173
3174 static PyObject *_wrap_Pen_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3175     PyObject *resultobj;
3176     wxPen *arg1 = (wxPen *) 0 ;
3177     int result;
3178     PyObject * obj0 = 0 ;
3179     char *kwnames[] = {
3180         (char *) "self", NULL
3181     };
3182
3183     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetStyle",kwnames,&obj0)) goto fail;
3184     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3185     if (SWIG_arg_fail(1)) SWIG_fail;
3186     {
3187         PyThreadState* __tstate = wxPyBeginAllowThreads();
3188         result = (int)(arg1)->GetStyle();
3189
3190         wxPyEndAllowThreads(__tstate);
3191         if (PyErr_Occurred()) SWIG_fail;
3192     }
3193     {
3194         resultobj = SWIG_From_int((int)(result));
3195     }
3196     return resultobj;
3197     fail:
3198     return NULL;
3199 }
3200
3201
3202 static PyObject *_wrap_Pen_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3203     PyObject *resultobj;
3204     wxPen *arg1 = (wxPen *) 0 ;
3205     int result;
3206     PyObject * obj0 = 0 ;
3207     char *kwnames[] = {
3208         (char *) "self", NULL
3209     };
3210
3211     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetWidth",kwnames,&obj0)) goto fail;
3212     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3213     if (SWIG_arg_fail(1)) SWIG_fail;
3214     {
3215         PyThreadState* __tstate = wxPyBeginAllowThreads();
3216         result = (int)(arg1)->GetWidth();
3217
3218         wxPyEndAllowThreads(__tstate);
3219         if (PyErr_Occurred()) SWIG_fail;
3220     }
3221     {
3222         resultobj = SWIG_From_int((int)(result));
3223     }
3224     return resultobj;
3225     fail:
3226     return NULL;
3227 }
3228
3229
3230 static PyObject *_wrap_Pen_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3231     PyObject *resultobj;
3232     wxPen *arg1 = (wxPen *) 0 ;
3233     bool result;
3234     PyObject * obj0 = 0 ;
3235     char *kwnames[] = {
3236         (char *) "self", NULL
3237     };
3238
3239     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_Ok",kwnames,&obj0)) goto fail;
3240     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3241     if (SWIG_arg_fail(1)) SWIG_fail;
3242     {
3243         PyThreadState* __tstate = wxPyBeginAllowThreads();
3244         result = (bool)(arg1)->Ok();
3245
3246         wxPyEndAllowThreads(__tstate);
3247         if (PyErr_Occurred()) SWIG_fail;
3248     }
3249     {
3250         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3251     }
3252     return resultobj;
3253     fail:
3254     return NULL;
3255 }
3256
3257
3258 static PyObject *_wrap_Pen_SetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3259     PyObject *resultobj;
3260     wxPen *arg1 = (wxPen *) 0 ;
3261     int arg2 ;
3262     PyObject * obj0 = 0 ;
3263     PyObject * obj1 = 0 ;
3264     char *kwnames[] = {
3265         (char *) "self",(char *) "cap_style", NULL
3266     };
3267
3268     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetCap",kwnames,&obj0,&obj1)) goto fail;
3269     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3270     if (SWIG_arg_fail(1)) SWIG_fail;
3271     {
3272         arg2 = (int)(SWIG_As_int(obj1));
3273         if (SWIG_arg_fail(2)) SWIG_fail;
3274     }
3275     {
3276         PyThreadState* __tstate = wxPyBeginAllowThreads();
3277         (arg1)->SetCap(arg2);
3278
3279         wxPyEndAllowThreads(__tstate);
3280         if (PyErr_Occurred()) SWIG_fail;
3281     }
3282     Py_INCREF(Py_None); resultobj = Py_None;
3283     return resultobj;
3284     fail:
3285     return NULL;
3286 }
3287
3288
3289 static PyObject *_wrap_Pen_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3290     PyObject *resultobj;
3291     wxPen *arg1 = (wxPen *) 0 ;
3292     wxColour *arg2 = 0 ;
3293     wxColour temp2 ;
3294     PyObject * obj0 = 0 ;
3295     PyObject * obj1 = 0 ;
3296     char *kwnames[] = {
3297         (char *) "self",(char *) "colour", NULL
3298     };
3299
3300     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetColour",kwnames,&obj0,&obj1)) goto fail;
3301     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3302     if (SWIG_arg_fail(1)) SWIG_fail;
3303     {
3304         arg2 = &temp2;
3305         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3306     }
3307     {
3308         PyThreadState* __tstate = wxPyBeginAllowThreads();
3309         (arg1)->SetColour(*arg2);
3310
3311         wxPyEndAllowThreads(__tstate);
3312         if (PyErr_Occurred()) SWIG_fail;
3313     }
3314     Py_INCREF(Py_None); resultobj = Py_None;
3315     return resultobj;
3316     fail:
3317     return NULL;
3318 }
3319
3320
3321 static PyObject *_wrap_Pen_SetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3322     PyObject *resultobj;
3323     wxPen *arg1 = (wxPen *) 0 ;
3324     int arg2 ;
3325     PyObject * obj0 = 0 ;
3326     PyObject * obj1 = 0 ;
3327     char *kwnames[] = {
3328         (char *) "self",(char *) "join_style", NULL
3329     };
3330
3331     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetJoin",kwnames,&obj0,&obj1)) goto fail;
3332     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3333     if (SWIG_arg_fail(1)) SWIG_fail;
3334     {
3335         arg2 = (int)(SWIG_As_int(obj1));
3336         if (SWIG_arg_fail(2)) SWIG_fail;
3337     }
3338     {
3339         PyThreadState* __tstate = wxPyBeginAllowThreads();
3340         (arg1)->SetJoin(arg2);
3341
3342         wxPyEndAllowThreads(__tstate);
3343         if (PyErr_Occurred()) SWIG_fail;
3344     }
3345     Py_INCREF(Py_None); resultobj = Py_None;
3346     return resultobj;
3347     fail:
3348     return NULL;
3349 }
3350
3351
3352 static PyObject *_wrap_Pen_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3353     PyObject *resultobj;
3354     wxPen *arg1 = (wxPen *) 0 ;
3355     int arg2 ;
3356     PyObject * obj0 = 0 ;
3357     PyObject * obj1 = 0 ;
3358     char *kwnames[] = {
3359         (char *) "self",(char *) "style", NULL
3360     };
3361
3362     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3363     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3364     if (SWIG_arg_fail(1)) SWIG_fail;
3365     {
3366         arg2 = (int)(SWIG_As_int(obj1));
3367         if (SWIG_arg_fail(2)) SWIG_fail;
3368     }
3369     {
3370         PyThreadState* __tstate = wxPyBeginAllowThreads();
3371         (arg1)->SetStyle(arg2);
3372
3373         wxPyEndAllowThreads(__tstate);
3374         if (PyErr_Occurred()) SWIG_fail;
3375     }
3376     Py_INCREF(Py_None); resultobj = Py_None;
3377     return resultobj;
3378     fail:
3379     return NULL;
3380 }
3381
3382
3383 static PyObject *_wrap_Pen_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3384     PyObject *resultobj;
3385     wxPen *arg1 = (wxPen *) 0 ;
3386     int arg2 ;
3387     PyObject * obj0 = 0 ;
3388     PyObject * obj1 = 0 ;
3389     char *kwnames[] = {
3390         (char *) "self",(char *) "width", NULL
3391     };
3392
3393     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3394     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3395     if (SWIG_arg_fail(1)) SWIG_fail;
3396     {
3397         arg2 = (int)(SWIG_As_int(obj1));
3398         if (SWIG_arg_fail(2)) SWIG_fail;
3399     }
3400     {
3401         PyThreadState* __tstate = wxPyBeginAllowThreads();
3402         (arg1)->SetWidth(arg2);
3403
3404         wxPyEndAllowThreads(__tstate);
3405         if (PyErr_Occurred()) SWIG_fail;
3406     }
3407     Py_INCREF(Py_None); resultobj = Py_None;
3408     return resultobj;
3409     fail:
3410     return NULL;
3411 }
3412
3413
3414 static PyObject *_wrap_Pen_SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3415     PyObject *resultobj;
3416     wxPen *arg1 = (wxPen *) 0 ;
3417     int arg2 ;
3418     wxDash *arg3 = (wxDash *) 0 ;
3419     PyObject * obj0 = 0 ;
3420     PyObject * obj1 = 0 ;
3421     char *kwnames[] = {
3422         (char *) "self",(char *) "dashes", NULL
3423     };
3424
3425     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetDashes",kwnames,&obj0,&obj1)) goto fail;
3426     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3427     if (SWIG_arg_fail(1)) SWIG_fail;
3428     {
3429         arg2 = PyList_Size(obj1);
3430         arg3 = (wxDash*)byte_LIST_helper(obj1);
3431         if (arg3 == NULL) SWIG_fail;
3432     }
3433     {
3434         PyThreadState* __tstate = wxPyBeginAllowThreads();
3435         (arg1)->SetDashes(arg2,arg3);
3436
3437         wxPyEndAllowThreads(__tstate);
3438         if (PyErr_Occurred()) SWIG_fail;
3439     }
3440     Py_INCREF(Py_None); resultobj = Py_None;
3441     {
3442         if (arg3) delete [] arg3;
3443     }
3444     return resultobj;
3445     fail:
3446     {
3447         if (arg3) delete [] arg3;
3448     }
3449     return NULL;
3450 }
3451
3452
3453 static PyObject *_wrap_Pen_GetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3454     PyObject *resultobj;
3455     wxPen *arg1 = (wxPen *) 0 ;
3456     PyObject *result;
3457     PyObject * obj0 = 0 ;
3458     char *kwnames[] = {
3459         (char *) "self", NULL
3460     };
3461
3462     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashes",kwnames,&obj0)) goto fail;
3463     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3464     if (SWIG_arg_fail(1)) SWIG_fail;
3465     {
3466         PyThreadState* __tstate = wxPyBeginAllowThreads();
3467         result = (PyObject *)wxPen_GetDashes(arg1);
3468
3469         wxPyEndAllowThreads(__tstate);
3470         if (PyErr_Occurred()) SWIG_fail;
3471     }
3472     resultobj = result;
3473     return resultobj;
3474     fail:
3475     return NULL;
3476 }
3477
3478
3479 static PyObject *_wrap_Pen__SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3480     PyObject *resultobj;
3481     wxPen *arg1 = (wxPen *) 0 ;
3482     PyObject *arg2 = (PyObject *) 0 ;
3483     PyObject *arg3 = (PyObject *) 0 ;
3484     PyObject * obj0 = 0 ;
3485     PyObject * obj1 = 0 ;
3486     PyObject * obj2 = 0 ;
3487     char *kwnames[] = {
3488         (char *) "self",(char *) "_self",(char *) "pyDashes", NULL
3489     };
3490
3491     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Pen__SetDashes",kwnames,&obj0,&obj1,&obj2)) goto fail;
3492     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3493     if (SWIG_arg_fail(1)) SWIG_fail;
3494     arg2 = obj1;
3495     arg3 = obj2;
3496     {
3497         PyThreadState* __tstate = wxPyBeginAllowThreads();
3498         wxPen__SetDashes(arg1,arg2,arg3);
3499
3500         wxPyEndAllowThreads(__tstate);
3501         if (PyErr_Occurred()) SWIG_fail;
3502     }
3503     Py_INCREF(Py_None); resultobj = Py_None;
3504     return resultobj;
3505     fail:
3506     return NULL;
3507 }
3508
3509
3510 static PyObject *_wrap_Pen_GetDashCount(PyObject *, PyObject *args, PyObject *kwargs) {
3511     PyObject *resultobj;
3512     wxPen *arg1 = (wxPen *) 0 ;
3513     int result;
3514     PyObject * obj0 = 0 ;
3515     char *kwnames[] = {
3516         (char *) "self", NULL
3517     };
3518
3519     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashCount",kwnames,&obj0)) goto fail;
3520     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3521     if (SWIG_arg_fail(1)) SWIG_fail;
3522     {
3523         PyThreadState* __tstate = wxPyBeginAllowThreads();
3524         result = (int)((wxPen const *)arg1)->GetDashCount();
3525
3526         wxPyEndAllowThreads(__tstate);
3527         if (PyErr_Occurred()) SWIG_fail;
3528     }
3529     {
3530         resultobj = SWIG_From_int((int)(result));
3531     }
3532     return resultobj;
3533     fail:
3534     return NULL;
3535 }
3536
3537
3538 static PyObject *_wrap_Pen_GetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3539     PyObject *resultobj;
3540     wxPen *arg1 = (wxPen *) 0 ;
3541     wxBitmap *result;
3542     PyObject * obj0 = 0 ;
3543     char *kwnames[] = {
3544         (char *) "self", NULL
3545     };
3546
3547     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetStipple",kwnames,&obj0)) goto fail;
3548     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3549     if (SWIG_arg_fail(1)) SWIG_fail;
3550     {
3551         PyThreadState* __tstate = wxPyBeginAllowThreads();
3552         result = (wxBitmap *)(arg1)->GetStipple();
3553
3554         wxPyEndAllowThreads(__tstate);
3555         if (PyErr_Occurred()) SWIG_fail;
3556     }
3557     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 0);
3558     return resultobj;
3559     fail:
3560     return NULL;
3561 }
3562
3563
3564 static PyObject *_wrap_Pen_SetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3565     PyObject *resultobj;
3566     wxPen *arg1 = (wxPen *) 0 ;
3567     wxBitmap *arg2 = 0 ;
3568     PyObject * obj0 = 0 ;
3569     PyObject * obj1 = 0 ;
3570     char *kwnames[] = {
3571         (char *) "self",(char *) "stipple", NULL
3572     };
3573
3574     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStipple",kwnames,&obj0,&obj1)) goto fail;
3575     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3576     if (SWIG_arg_fail(1)) SWIG_fail;
3577     {
3578         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3579         if (SWIG_arg_fail(2)) SWIG_fail;
3580         if (arg2 == NULL) {
3581             SWIG_null_ref("wxBitmap");
3582         }
3583         if (SWIG_arg_fail(2)) SWIG_fail;
3584     }
3585     {
3586         PyThreadState* __tstate = wxPyBeginAllowThreads();
3587         (arg1)->SetStipple(*arg2);
3588
3589         wxPyEndAllowThreads(__tstate);
3590         if (PyErr_Occurred()) SWIG_fail;
3591     }
3592     Py_INCREF(Py_None); resultobj = Py_None;
3593     return resultobj;
3594     fail:
3595     return NULL;
3596 }
3597
3598
3599 static PyObject *_wrap_Pen___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3600     PyObject *resultobj;
3601     wxPen *arg1 = (wxPen *) 0 ;
3602     wxPen *arg2 = (wxPen *) 0 ;
3603     bool result;
3604     PyObject * obj0 = 0 ;
3605     PyObject * obj1 = 0 ;
3606     char *kwnames[] = {
3607         (char *) "self",(char *) "other", NULL
3608     };
3609
3610     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___eq__",kwnames,&obj0,&obj1)) goto fail;
3611     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3612     if (SWIG_arg_fail(1)) SWIG_fail;
3613     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3614     if (SWIG_arg_fail(2)) SWIG_fail;
3615     {
3616         PyThreadState* __tstate = wxPyBeginAllowThreads();
3617         result = (bool)wxPen___eq__(arg1,(wxPen const *)arg2);
3618
3619         wxPyEndAllowThreads(__tstate);
3620         if (PyErr_Occurred()) SWIG_fail;
3621     }
3622     {
3623         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3624     }
3625     return resultobj;
3626     fail:
3627     return NULL;
3628 }
3629
3630
3631 static PyObject *_wrap_Pen___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3632     PyObject *resultobj;
3633     wxPen *arg1 = (wxPen *) 0 ;
3634     wxPen *arg2 = (wxPen *) 0 ;
3635     bool result;
3636     PyObject * obj0 = 0 ;
3637     PyObject * obj1 = 0 ;
3638     char *kwnames[] = {
3639         (char *) "self",(char *) "other", NULL
3640     };
3641
3642     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___ne__",kwnames,&obj0,&obj1)) goto fail;
3643     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3644     if (SWIG_arg_fail(1)) SWIG_fail;
3645     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3646     if (SWIG_arg_fail(2)) SWIG_fail;
3647     {
3648         PyThreadState* __tstate = wxPyBeginAllowThreads();
3649         result = (bool)wxPen___ne__(arg1,(wxPen const *)arg2);
3650
3651         wxPyEndAllowThreads(__tstate);
3652         if (PyErr_Occurred()) SWIG_fail;
3653     }
3654     {
3655         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3656     }
3657     return resultobj;
3658     fail:
3659     return NULL;
3660 }
3661
3662
3663 static PyObject * Pen_swigregister(PyObject *, PyObject *args) {
3664     PyObject *obj;
3665     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3666     SWIG_TypeClientData(SWIGTYPE_p_wxPen, obj);
3667     Py_INCREF(obj);
3668     return Py_BuildValue((char *)"");
3669 }
3670 static PyObject *_wrap_new_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3671     PyObject *resultobj;
3672     wxColour *arg1 = 0 ;
3673     int arg2 = (int) wxSOLID ;
3674     wxBrush *result;
3675     wxColour temp1 ;
3676     PyObject * obj0 = 0 ;
3677     PyObject * obj1 = 0 ;
3678     char *kwnames[] = {
3679         (char *) "colour",(char *) "style", NULL
3680     };
3681
3682     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Brush",kwnames,&obj0,&obj1)) goto fail;
3683     {
3684         arg1 = &temp1;
3685         if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3686     }
3687     if (obj1) {
3688         {
3689             arg2 = (int)(SWIG_As_int(obj1));
3690             if (SWIG_arg_fail(2)) SWIG_fail;
3691         }
3692     }
3693     {
3694         if (!wxPyCheckForApp()) SWIG_fail;
3695         PyThreadState* __tstate = wxPyBeginAllowThreads();
3696         result = (wxBrush *)new wxBrush((wxColour const &)*arg1,arg2);
3697
3698         wxPyEndAllowThreads(__tstate);
3699         if (PyErr_Occurred()) SWIG_fail;
3700     }
3701     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 1);
3702     return resultobj;
3703     fail:
3704     return NULL;
3705 }
3706
3707
3708 static PyObject *_wrap_delete_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3709     PyObject *resultobj;
3710     wxBrush *arg1 = (wxBrush *) 0 ;
3711     PyObject * obj0 = 0 ;
3712     char *kwnames[] = {
3713         (char *) "self", NULL
3714     };
3715
3716     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Brush",kwnames,&obj0)) goto fail;
3717     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3718     if (SWIG_arg_fail(1)) SWIG_fail;
3719     {
3720         PyThreadState* __tstate = wxPyBeginAllowThreads();
3721         delete arg1;
3722
3723         wxPyEndAllowThreads(__tstate);
3724         if (PyErr_Occurred()) SWIG_fail;
3725     }
3726     Py_INCREF(Py_None); resultobj = Py_None;
3727     return resultobj;
3728     fail:
3729     return NULL;
3730 }
3731
3732
3733 static PyObject *_wrap_Brush_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3734     PyObject *resultobj;
3735     wxBrush *arg1 = (wxBrush *) 0 ;
3736     wxColour *arg2 = 0 ;
3737     wxColour temp2 ;
3738     PyObject * obj0 = 0 ;
3739     PyObject * obj1 = 0 ;
3740     char *kwnames[] = {
3741         (char *) "self",(char *) "col", NULL
3742     };
3743
3744     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetColour",kwnames,&obj0,&obj1)) goto fail;
3745     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3746     if (SWIG_arg_fail(1)) SWIG_fail;
3747     {
3748         arg2 = &temp2;
3749         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3750     }
3751     {
3752         PyThreadState* __tstate = wxPyBeginAllowThreads();
3753         (arg1)->SetColour((wxColour const &)*arg2);
3754
3755         wxPyEndAllowThreads(__tstate);
3756         if (PyErr_Occurred()) SWIG_fail;
3757     }
3758     Py_INCREF(Py_None); resultobj = Py_None;
3759     return resultobj;
3760     fail:
3761     return NULL;
3762 }
3763
3764
3765 static PyObject *_wrap_Brush_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3766     PyObject *resultobj;
3767     wxBrush *arg1 = (wxBrush *) 0 ;
3768     int arg2 ;
3769     PyObject * obj0 = 0 ;
3770     PyObject * obj1 = 0 ;
3771     char *kwnames[] = {
3772         (char *) "self",(char *) "style", NULL
3773     };
3774
3775     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3776     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3777     if (SWIG_arg_fail(1)) SWIG_fail;
3778     {
3779         arg2 = (int)(SWIG_As_int(obj1));
3780         if (SWIG_arg_fail(2)) SWIG_fail;
3781     }
3782     {
3783         PyThreadState* __tstate = wxPyBeginAllowThreads();
3784         (arg1)->SetStyle(arg2);
3785
3786         wxPyEndAllowThreads(__tstate);
3787         if (PyErr_Occurred()) SWIG_fail;
3788     }
3789     Py_INCREF(Py_None); resultobj = Py_None;
3790     return resultobj;
3791     fail:
3792     return NULL;
3793 }
3794
3795
3796 static PyObject *_wrap_Brush_SetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3797     PyObject *resultobj;
3798     wxBrush *arg1 = (wxBrush *) 0 ;
3799     wxBitmap *arg2 = 0 ;
3800     PyObject * obj0 = 0 ;
3801     PyObject * obj1 = 0 ;
3802     char *kwnames[] = {
3803         (char *) "self",(char *) "stipple", NULL
3804     };
3805
3806     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStipple",kwnames,&obj0,&obj1)) goto fail;
3807     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3808     if (SWIG_arg_fail(1)) SWIG_fail;
3809     {
3810         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3811         if (SWIG_arg_fail(2)) SWIG_fail;
3812         if (arg2 == NULL) {
3813             SWIG_null_ref("wxBitmap");
3814         }
3815         if (SWIG_arg_fail(2)) SWIG_fail;
3816     }
3817     {
3818         PyThreadState* __tstate = wxPyBeginAllowThreads();
3819         (arg1)->SetStipple((wxBitmap const &)*arg2);
3820
3821         wxPyEndAllowThreads(__tstate);
3822         if (PyErr_Occurred()) SWIG_fail;
3823     }
3824     Py_INCREF(Py_None); resultobj = Py_None;
3825     return resultobj;
3826     fail:
3827     return NULL;
3828 }
3829
3830
3831 static PyObject *_wrap_Brush_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3832     PyObject *resultobj;
3833     wxBrush *arg1 = (wxBrush *) 0 ;
3834     wxColour result;
3835     PyObject * obj0 = 0 ;
3836     char *kwnames[] = {
3837         (char *) "self", NULL
3838     };
3839
3840     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetColour",kwnames,&obj0)) 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         PyThreadState* __tstate = wxPyBeginAllowThreads();
3845         result = ((wxBrush const *)arg1)->GetColour();
3846
3847         wxPyEndAllowThreads(__tstate);
3848         if (PyErr_Occurred()) SWIG_fail;
3849     }
3850     {
3851         wxColour * resultptr;
3852         resultptr = new wxColour((wxColour &)(result));
3853         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3854     }
3855     return resultobj;
3856     fail:
3857     return NULL;
3858 }
3859
3860
3861 static PyObject *_wrap_Brush_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3862     PyObject *resultobj;
3863     wxBrush *arg1 = (wxBrush *) 0 ;
3864     int result;
3865     PyObject * obj0 = 0 ;
3866     char *kwnames[] = {
3867         (char *) "self", NULL
3868     };
3869
3870     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStyle",kwnames,&obj0)) goto fail;
3871     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3872     if (SWIG_arg_fail(1)) SWIG_fail;
3873     {
3874         PyThreadState* __tstate = wxPyBeginAllowThreads();
3875         result = (int)((wxBrush const *)arg1)->GetStyle();
3876
3877         wxPyEndAllowThreads(__tstate);
3878         if (PyErr_Occurred()) SWIG_fail;
3879     }
3880     {
3881         resultobj = SWIG_From_int((int)(result));
3882     }
3883     return resultobj;
3884     fail:
3885     return NULL;
3886 }
3887
3888
3889 static PyObject *_wrap_Brush_GetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3890     PyObject *resultobj;
3891     wxBrush *arg1 = (wxBrush *) 0 ;
3892     wxBitmap *result;
3893     PyObject * obj0 = 0 ;
3894     char *kwnames[] = {
3895         (char *) "self", NULL
3896     };
3897
3898     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStipple",kwnames,&obj0)) goto fail;
3899     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3900     if (SWIG_arg_fail(1)) SWIG_fail;
3901     {
3902         PyThreadState* __tstate = wxPyBeginAllowThreads();
3903         result = (wxBitmap *)((wxBrush const *)arg1)->GetStipple();
3904
3905         wxPyEndAllowThreads(__tstate);
3906         if (PyErr_Occurred()) SWIG_fail;
3907     }
3908     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 0);
3909     return resultobj;
3910     fail:
3911     return NULL;
3912 }
3913
3914
3915 static PyObject *_wrap_Brush_IsHatch(PyObject *, PyObject *args, PyObject *kwargs) {
3916     PyObject *resultobj;
3917     wxBrush *arg1 = (wxBrush *) 0 ;
3918     bool result;
3919     PyObject * obj0 = 0 ;
3920     char *kwnames[] = {
3921         (char *) "self", NULL
3922     };
3923
3924     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_IsHatch",kwnames,&obj0)) goto fail;
3925     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3926     if (SWIG_arg_fail(1)) SWIG_fail;
3927     {
3928         PyThreadState* __tstate = wxPyBeginAllowThreads();
3929         result = (bool)((wxBrush const *)arg1)->IsHatch();
3930
3931         wxPyEndAllowThreads(__tstate);
3932         if (PyErr_Occurred()) SWIG_fail;
3933     }
3934     {
3935         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3936     }
3937     return resultobj;
3938     fail:
3939     return NULL;
3940 }
3941
3942
3943 static PyObject *_wrap_Brush_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3944     PyObject *resultobj;
3945     wxBrush *arg1 = (wxBrush *) 0 ;
3946     bool result;
3947     PyObject * obj0 = 0 ;
3948     char *kwnames[] = {
3949         (char *) "self", NULL
3950     };
3951
3952     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_Ok",kwnames,&obj0)) goto fail;
3953     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3954     if (SWIG_arg_fail(1)) SWIG_fail;
3955     {
3956         PyThreadState* __tstate = wxPyBeginAllowThreads();
3957         result = (bool)(arg1)->Ok();
3958
3959         wxPyEndAllowThreads(__tstate);
3960         if (PyErr_Occurred()) SWIG_fail;
3961     }
3962     {
3963         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3964     }
3965     return resultobj;
3966     fail:
3967     return NULL;
3968 }
3969
3970
3971 static PyObject * Brush_swigregister(PyObject *, PyObject *args) {
3972     PyObject *obj;
3973     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3974     SWIG_TypeClientData(SWIGTYPE_p_wxBrush, obj);
3975     Py_INCREF(obj);
3976     return Py_BuildValue((char *)"");
3977 }
3978 static PyObject *_wrap_new_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
3979     PyObject *resultobj;
3980     wxString *arg1 = 0 ;
3981     wxBitmapType arg2 = (wxBitmapType) wxBITMAP_TYPE_ANY ;
3982     wxBitmap *result;
3983     bool temp1 = false ;
3984     PyObject * obj0 = 0 ;
3985     PyObject * obj1 = 0 ;
3986     char *kwnames[] = {
3987         (char *) "name",(char *) "type", NULL
3988     };
3989
3990     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Bitmap",kwnames,&obj0,&obj1)) goto fail;
3991     {
3992         arg1 = wxString_in_helper(obj0);
3993         if (arg1 == NULL) SWIG_fail;
3994         temp1 = true;
3995     }
3996     if (obj1) {
3997         {
3998             arg2 = (wxBitmapType)(SWIG_As_int(obj1));
3999             if (SWIG_arg_fail(2)) SWIG_fail;
4000         }
4001     }
4002     {
4003         if (!wxPyCheckForApp()) SWIG_fail;
4004         PyThreadState* __tstate = wxPyBeginAllowThreads();
4005         result = (wxBitmap *)new wxBitmap((wxString const &)*arg1,(wxBitmapType )arg2);
4006
4007         wxPyEndAllowThreads(__tstate);
4008         if (PyErr_Occurred()) SWIG_fail;
4009     }
4010     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4011     {
4012         if (temp1)
4013         delete arg1;
4014     }
4015     return resultobj;
4016     fail:
4017     {
4018         if (temp1)
4019         delete arg1;
4020     }
4021     return NULL;
4022 }
4023
4024
4025 static PyObject *_wrap_delete_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4026     PyObject *resultobj;
4027     wxBitmap *arg1 = (wxBitmap *) 0 ;
4028     PyObject * obj0 = 0 ;
4029     char *kwnames[] = {
4030         (char *) "self", NULL
4031     };
4032
4033     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Bitmap",kwnames,&obj0)) goto fail;
4034     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4035     if (SWIG_arg_fail(1)) SWIG_fail;
4036     {
4037         PyThreadState* __tstate = wxPyBeginAllowThreads();
4038         delete arg1;
4039
4040         wxPyEndAllowThreads(__tstate);
4041         if (PyErr_Occurred()) SWIG_fail;
4042     }
4043     Py_INCREF(Py_None); resultobj = Py_None;
4044     return resultobj;
4045     fail:
4046     return NULL;
4047 }
4048
4049
4050 static PyObject *_wrap_new_EmptyBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4051     PyObject *resultobj;
4052     int arg1 ;
4053     int arg2 ;
4054     int arg3 = (int) -1 ;
4055     wxBitmap *result;
4056     PyObject * obj0 = 0 ;
4057     PyObject * obj1 = 0 ;
4058     PyObject * obj2 = 0 ;
4059     char *kwnames[] = {
4060         (char *) "width",(char *) "height",(char *) "depth", NULL
4061     };
4062
4063     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_EmptyBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
4064     {
4065         arg1 = (int)(SWIG_As_int(obj0));
4066         if (SWIG_arg_fail(1)) SWIG_fail;
4067     }
4068     {
4069         arg2 = (int)(SWIG_As_int(obj1));
4070         if (SWIG_arg_fail(2)) SWIG_fail;
4071     }
4072     if (obj2) {
4073         {
4074             arg3 = (int)(SWIG_As_int(obj2));
4075             if (SWIG_arg_fail(3)) SWIG_fail;
4076         }
4077     }
4078     {
4079         if (!wxPyCheckForApp()) SWIG_fail;
4080         PyThreadState* __tstate = wxPyBeginAllowThreads();
4081         result = (wxBitmap *)new wxBitmap(arg1,arg2,arg3);
4082
4083         wxPyEndAllowThreads(__tstate);
4084         if (PyErr_Occurred()) SWIG_fail;
4085     }
4086     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4087     return resultobj;
4088     fail:
4089     return NULL;
4090 }
4091
4092
4093 static PyObject *_wrap_new_BitmapFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4094     PyObject *resultobj;
4095     wxIcon *arg1 = 0 ;
4096     wxBitmap *result;
4097     PyObject * obj0 = 0 ;
4098     char *kwnames[] = {
4099         (char *) "icon", NULL
4100     };
4101
4102     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromIcon",kwnames,&obj0)) goto fail;
4103     {
4104         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4105         if (SWIG_arg_fail(1)) SWIG_fail;
4106         if (arg1 == NULL) {
4107             SWIG_null_ref("wxIcon");
4108         }
4109         if (SWIG_arg_fail(1)) SWIG_fail;
4110     }
4111     {
4112         if (!wxPyCheckForApp()) SWIG_fail;
4113         PyThreadState* __tstate = wxPyBeginAllowThreads();
4114         result = (wxBitmap *)new wxBitmap((wxIcon const &)*arg1);
4115
4116         wxPyEndAllowThreads(__tstate);
4117         if (PyErr_Occurred()) SWIG_fail;
4118     }
4119     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4120     return resultobj;
4121     fail:
4122     return NULL;
4123 }
4124
4125
4126 static PyObject *_wrap_new_BitmapFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
4127     PyObject *resultobj;
4128     wxImage *arg1 = 0 ;
4129     int arg2 = (int) -1 ;
4130     wxBitmap *result;
4131     PyObject * obj0 = 0 ;
4132     PyObject * obj1 = 0 ;
4133     char *kwnames[] = {
4134         (char *) "image",(char *) "depth", NULL
4135     };
4136
4137     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BitmapFromImage",kwnames,&obj0,&obj1)) goto fail;
4138     {
4139         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
4140         if (SWIG_arg_fail(1)) SWIG_fail;
4141         if (arg1 == NULL) {
4142             SWIG_null_ref("wxImage");
4143         }
4144         if (SWIG_arg_fail(1)) SWIG_fail;
4145     }
4146     if (obj1) {
4147         {
4148             arg2 = (int)(SWIG_As_int(obj1));
4149             if (SWIG_arg_fail(2)) SWIG_fail;
4150         }
4151     }
4152     {
4153         if (!wxPyCheckForApp()) SWIG_fail;
4154         PyThreadState* __tstate = wxPyBeginAllowThreads();
4155         result = (wxBitmap *)new wxBitmap((wxImage const &)*arg1,arg2);
4156
4157         wxPyEndAllowThreads(__tstate);
4158         if (PyErr_Occurred()) SWIG_fail;
4159     }
4160     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4161     return resultobj;
4162     fail:
4163     return NULL;
4164 }
4165
4166
4167 static PyObject *_wrap_new_BitmapFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
4168     PyObject *resultobj;
4169     PyObject *arg1 = (PyObject *) 0 ;
4170     wxBitmap *result;
4171     PyObject * obj0 = 0 ;
4172     char *kwnames[] = {
4173         (char *) "listOfStrings", NULL
4174     };
4175
4176     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromXPMData",kwnames,&obj0)) goto fail;
4177     arg1 = obj0;
4178     {
4179         if (!wxPyCheckForApp()) SWIG_fail;
4180         PyThreadState* __tstate = wxPyBeginAllowThreads();
4181         result = (wxBitmap *)new_wxBitmap(arg1);
4182
4183         wxPyEndAllowThreads(__tstate);
4184         if (PyErr_Occurred()) SWIG_fail;
4185     }
4186     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4187     return resultobj;
4188     fail:
4189     return NULL;
4190 }
4191
4192
4193 static PyObject *_wrap_new_BitmapFromBits(PyObject *, PyObject *args, PyObject *kwargs) {
4194     PyObject *resultobj;
4195     PyObject *arg1 = (PyObject *) 0 ;
4196     int arg2 ;
4197     int arg3 ;
4198     int arg4 = (int) 1 ;
4199     wxBitmap *result;
4200     PyObject * obj0 = 0 ;
4201     PyObject * obj1 = 0 ;
4202     PyObject * obj2 = 0 ;
4203     PyObject * obj3 = 0 ;
4204     char *kwnames[] = {
4205         (char *) "bits",(char *) "width",(char *) "height",(char *) "depth", NULL
4206     };
4207
4208     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:new_BitmapFromBits",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4209     arg1 = obj0;
4210     {
4211         arg2 = (int)(SWIG_As_int(obj1));
4212         if (SWIG_arg_fail(2)) SWIG_fail;
4213     }
4214     {
4215         arg3 = (int)(SWIG_As_int(obj2));
4216         if (SWIG_arg_fail(3)) SWIG_fail;
4217     }
4218     if (obj3) {
4219         {
4220             arg4 = (int)(SWIG_As_int(obj3));
4221             if (SWIG_arg_fail(4)) SWIG_fail;
4222         }
4223     }
4224     {
4225         if (!wxPyCheckForApp()) SWIG_fail;
4226         PyThreadState* __tstate = wxPyBeginAllowThreads();
4227         result = (wxBitmap *)new_wxBitmap(arg1,arg2,arg3,arg4);
4228
4229         wxPyEndAllowThreads(__tstate);
4230         if (PyErr_Occurred()) SWIG_fail;
4231     }
4232     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4233     return resultobj;
4234     fail:
4235     return NULL;
4236 }
4237
4238
4239 static PyObject *_wrap_Bitmap_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
4240     PyObject *resultobj;
4241     wxBitmap *arg1 = (wxBitmap *) 0 ;
4242     long result;
4243     PyObject * obj0 = 0 ;
4244     char *kwnames[] = {
4245         (char *) "self", NULL
4246     };
4247
4248     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetHandle",kwnames,&obj0)) goto fail;
4249     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4250     if (SWIG_arg_fail(1)) SWIG_fail;
4251     {
4252         PyThreadState* __tstate = wxPyBeginAllowThreads();
4253         result = (long)(arg1)->GetHandle();
4254
4255         wxPyEndAllowThreads(__tstate);
4256         if (PyErr_Occurred()) SWIG_fail;
4257     }
4258     {
4259         resultobj = SWIG_From_long((long)(result));
4260     }
4261     return resultobj;
4262     fail:
4263     return NULL;
4264 }
4265
4266
4267 static PyObject *_wrap_Bitmap_SetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
4268     PyObject *resultobj;
4269     wxBitmap *arg1 = (wxBitmap *) 0 ;
4270     long arg2 ;
4271     PyObject * obj0 = 0 ;
4272     PyObject * obj1 = 0 ;
4273     char *kwnames[] = {
4274         (char *) "self",(char *) "handle", NULL
4275     };
4276
4277     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHandle",kwnames,&obj0,&obj1)) goto fail;
4278     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4279     if (SWIG_arg_fail(1)) SWIG_fail;
4280     {
4281         arg2 = (long)(SWIG_As_long(obj1));
4282         if (SWIG_arg_fail(2)) SWIG_fail;
4283     }
4284     {
4285         PyThreadState* __tstate = wxPyBeginAllowThreads();
4286         wxBitmap_SetHandle(arg1,arg2);
4287
4288         wxPyEndAllowThreads(__tstate);
4289         if (PyErr_Occurred()) SWIG_fail;
4290     }
4291     Py_INCREF(Py_None); resultobj = Py_None;
4292     return resultobj;
4293     fail:
4294     return NULL;
4295 }
4296
4297
4298 static PyObject *_wrap_Bitmap_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
4299     PyObject *resultobj;
4300     wxBitmap *arg1 = (wxBitmap *) 0 ;
4301     bool result;
4302     PyObject * obj0 = 0 ;
4303     char *kwnames[] = {
4304         (char *) "self", NULL
4305     };
4306
4307     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_Ok",kwnames,&obj0)) goto fail;
4308     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4309     if (SWIG_arg_fail(1)) SWIG_fail;
4310     {
4311         PyThreadState* __tstate = wxPyBeginAllowThreads();
4312         result = (bool)(arg1)->Ok();
4313
4314         wxPyEndAllowThreads(__tstate);
4315         if (PyErr_Occurred()) SWIG_fail;
4316     }
4317     {
4318         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4319     }
4320     return resultobj;
4321     fail:
4322     return NULL;
4323 }
4324
4325
4326 static PyObject *_wrap_Bitmap_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4327     PyObject *resultobj;
4328     wxBitmap *arg1 = (wxBitmap *) 0 ;
4329     int result;
4330     PyObject * obj0 = 0 ;
4331     char *kwnames[] = {
4332         (char *) "self", NULL
4333     };
4334
4335     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetWidth",kwnames,&obj0)) goto fail;
4336     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4337     if (SWIG_arg_fail(1)) SWIG_fail;
4338     {
4339         PyThreadState* __tstate = wxPyBeginAllowThreads();
4340         result = (int)(arg1)->GetWidth();
4341
4342         wxPyEndAllowThreads(__tstate);
4343         if (PyErr_Occurred()) SWIG_fail;
4344     }
4345     {
4346         resultobj = SWIG_From_int((int)(result));
4347     }
4348     return resultobj;
4349     fail:
4350     return NULL;
4351 }
4352
4353
4354 static PyObject *_wrap_Bitmap_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4355     PyObject *resultobj;
4356     wxBitmap *arg1 = (wxBitmap *) 0 ;
4357     int result;
4358     PyObject * obj0 = 0 ;
4359     char *kwnames[] = {
4360         (char *) "self", NULL
4361     };
4362
4363     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetHeight",kwnames,&obj0)) goto fail;
4364     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4365     if (SWIG_arg_fail(1)) SWIG_fail;
4366     {
4367         PyThreadState* __tstate = wxPyBeginAllowThreads();
4368         result = (int)(arg1)->GetHeight();
4369
4370         wxPyEndAllowThreads(__tstate);
4371         if (PyErr_Occurred()) SWIG_fail;
4372     }
4373     {
4374         resultobj = SWIG_From_int((int)(result));
4375     }
4376     return resultobj;
4377     fail:
4378     return NULL;
4379 }
4380
4381
4382 static PyObject *_wrap_Bitmap_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4383     PyObject *resultobj;
4384     wxBitmap *arg1 = (wxBitmap *) 0 ;
4385     int result;
4386     PyObject * obj0 = 0 ;
4387     char *kwnames[] = {
4388         (char *) "self", NULL
4389     };
4390
4391     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetDepth",kwnames,&obj0)) goto fail;
4392     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4393     if (SWIG_arg_fail(1)) SWIG_fail;
4394     {
4395         PyThreadState* __tstate = wxPyBeginAllowThreads();
4396         result = (int)(arg1)->GetDepth();
4397
4398         wxPyEndAllowThreads(__tstate);
4399         if (PyErr_Occurred()) SWIG_fail;
4400     }
4401     {
4402         resultobj = SWIG_From_int((int)(result));
4403     }
4404     return resultobj;
4405     fail:
4406     return NULL;
4407 }
4408
4409
4410 static PyObject *_wrap_Bitmap_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4411     PyObject *resultobj;
4412     wxBitmap *arg1 = (wxBitmap *) 0 ;
4413     wxSize result;
4414     PyObject * obj0 = 0 ;
4415     char *kwnames[] = {
4416         (char *) "self", NULL
4417     };
4418
4419     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetSize",kwnames,&obj0)) goto fail;
4420     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4421     if (SWIG_arg_fail(1)) SWIG_fail;
4422     {
4423         PyThreadState* __tstate = wxPyBeginAllowThreads();
4424         result = wxBitmap_GetSize(arg1);
4425
4426         wxPyEndAllowThreads(__tstate);
4427         if (PyErr_Occurred()) SWIG_fail;
4428     }
4429     {
4430         wxSize * resultptr;
4431         resultptr = new wxSize((wxSize &)(result));
4432         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
4433     }
4434     return resultobj;
4435     fail:
4436     return NULL;
4437 }
4438
4439
4440 static PyObject *_wrap_Bitmap_ConvertToImage(PyObject *, PyObject *args, PyObject *kwargs) {
4441     PyObject *resultobj;
4442     wxBitmap *arg1 = (wxBitmap *) 0 ;
4443     SwigValueWrapper<wxImage > result;
4444     PyObject * obj0 = 0 ;
4445     char *kwnames[] = {
4446         (char *) "self", NULL
4447     };
4448
4449     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_ConvertToImage",kwnames,&obj0)) goto fail;
4450     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4451     if (SWIG_arg_fail(1)) SWIG_fail;
4452     {
4453         PyThreadState* __tstate = wxPyBeginAllowThreads();
4454         result = ((wxBitmap const *)arg1)->ConvertToImage();
4455
4456         wxPyEndAllowThreads(__tstate);
4457         if (PyErr_Occurred()) SWIG_fail;
4458     }
4459     {
4460         wxImage * resultptr;
4461         resultptr = new wxImage((wxImage &)(result));
4462         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
4463     }
4464     return resultobj;
4465     fail:
4466     return NULL;
4467 }
4468
4469
4470 static PyObject *_wrap_Bitmap_GetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4471     PyObject *resultobj;
4472     wxBitmap *arg1 = (wxBitmap *) 0 ;
4473     wxMask *result;
4474     PyObject * obj0 = 0 ;
4475     char *kwnames[] = {
4476         (char *) "self", NULL
4477     };
4478
4479     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetMask",kwnames,&obj0)) goto fail;
4480     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4481     if (SWIG_arg_fail(1)) SWIG_fail;
4482     {
4483         PyThreadState* __tstate = wxPyBeginAllowThreads();
4484         result = (wxMask *)((wxBitmap const *)arg1)->GetMask();
4485
4486         wxPyEndAllowThreads(__tstate);
4487         if (PyErr_Occurred()) SWIG_fail;
4488     }
4489     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 0);
4490     return resultobj;
4491     fail:
4492     return NULL;
4493 }
4494
4495
4496 static PyObject *_wrap_Bitmap_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4497     PyObject *resultobj;
4498     wxBitmap *arg1 = (wxBitmap *) 0 ;
4499     wxMask *arg2 = (wxMask *) 0 ;
4500     PyObject * obj0 = 0 ;
4501     PyObject * obj1 = 0 ;
4502     char *kwnames[] = {
4503         (char *) "self",(char *) "mask", NULL
4504     };
4505
4506     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMask",kwnames,&obj0,&obj1)) goto fail;
4507     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4508     if (SWIG_arg_fail(1)) SWIG_fail;
4509     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMask, SWIG_POINTER_EXCEPTION | 0);
4510     if (SWIG_arg_fail(2)) SWIG_fail;
4511     {
4512         PyThreadState* __tstate = wxPyBeginAllowThreads();
4513         (arg1)->SetMask(arg2);
4514
4515         wxPyEndAllowThreads(__tstate);
4516         if (PyErr_Occurred()) SWIG_fail;
4517     }
4518     Py_INCREF(Py_None); resultobj = Py_None;
4519     return resultobj;
4520     fail:
4521     return NULL;
4522 }
4523
4524
4525 static PyObject *_wrap_Bitmap_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
4526     PyObject *resultobj;
4527     wxBitmap *arg1 = (wxBitmap *) 0 ;
4528     wxColour *arg2 = 0 ;
4529     wxColour temp2 ;
4530     PyObject * obj0 = 0 ;
4531     PyObject * obj1 = 0 ;
4532     char *kwnames[] = {
4533         (char *) "self",(char *) "colour", NULL
4534     };
4535
4536     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMaskColour",kwnames,&obj0,&obj1)) goto fail;
4537     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4538     if (SWIG_arg_fail(1)) SWIG_fail;
4539     {
4540         arg2 = &temp2;
4541         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4542     }
4543     {
4544         PyThreadState* __tstate = wxPyBeginAllowThreads();
4545         wxBitmap_SetMaskColour(arg1,(wxColour const &)*arg2);
4546
4547         wxPyEndAllowThreads(__tstate);
4548         if (PyErr_Occurred()) SWIG_fail;
4549     }
4550     Py_INCREF(Py_None); resultobj = Py_None;
4551     return resultobj;
4552     fail:
4553     return NULL;
4554 }
4555
4556
4557 static PyObject *_wrap_Bitmap_GetSubBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4558     PyObject *resultobj;
4559     wxBitmap *arg1 = (wxBitmap *) 0 ;
4560     wxRect *arg2 = 0 ;
4561     SwigValueWrapper<wxBitmap > result;
4562     wxRect temp2 ;
4563     PyObject * obj0 = 0 ;
4564     PyObject * obj1 = 0 ;
4565     char *kwnames[] = {
4566         (char *) "self",(char *) "rect", NULL
4567     };
4568
4569     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_GetSubBitmap",kwnames,&obj0,&obj1)) goto fail;
4570     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4571     if (SWIG_arg_fail(1)) SWIG_fail;
4572     {
4573         arg2 = &temp2;
4574         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4575     }
4576     {
4577         PyThreadState* __tstate = wxPyBeginAllowThreads();
4578         result = ((wxBitmap const *)arg1)->GetSubBitmap((wxRect const &)*arg2);
4579
4580         wxPyEndAllowThreads(__tstate);
4581         if (PyErr_Occurred()) SWIG_fail;
4582     }
4583     {
4584         wxBitmap * resultptr;
4585         resultptr = new wxBitmap((wxBitmap &)(result));
4586         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
4587     }
4588     return resultobj;
4589     fail:
4590     return NULL;
4591 }
4592
4593
4594 static PyObject *_wrap_Bitmap_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
4595     PyObject *resultobj;
4596     wxBitmap *arg1 = (wxBitmap *) 0 ;
4597     wxString *arg2 = 0 ;
4598     wxBitmapType arg3 ;
4599     wxPalette *arg4 = (wxPalette *) NULL ;
4600     bool result;
4601     bool temp2 = false ;
4602     PyObject * obj0 = 0 ;
4603     PyObject * obj1 = 0 ;
4604     PyObject * obj2 = 0 ;
4605     PyObject * obj3 = 0 ;
4606     char *kwnames[] = {
4607         (char *) "self",(char *) "name",(char *) "type",(char *) "palette", NULL
4608     };
4609
4610     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Bitmap_SaveFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4611     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4612     if (SWIG_arg_fail(1)) SWIG_fail;
4613     {
4614         arg2 = wxString_in_helper(obj1);
4615         if (arg2 == NULL) SWIG_fail;
4616         temp2 = true;
4617     }
4618     {
4619         arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4620         if (SWIG_arg_fail(3)) SWIG_fail;
4621     }
4622     if (obj3) {
4623         SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
4624         if (SWIG_arg_fail(4)) SWIG_fail;
4625     }
4626     {
4627         PyThreadState* __tstate = wxPyBeginAllowThreads();
4628         result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxBitmapType )arg3,arg4);
4629
4630         wxPyEndAllowThreads(__tstate);
4631         if (PyErr_Occurred()) SWIG_fail;
4632     }
4633     {
4634         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4635     }
4636     {
4637         if (temp2)
4638         delete arg2;
4639     }
4640     return resultobj;
4641     fail:
4642     {
4643         if (temp2)
4644         delete arg2;
4645     }
4646     return NULL;
4647 }
4648
4649
4650 static PyObject *_wrap_Bitmap_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
4651     PyObject *resultobj;
4652     wxBitmap *arg1 = (wxBitmap *) 0 ;
4653     wxString *arg2 = 0 ;
4654     wxBitmapType arg3 ;
4655     bool result;
4656     bool temp2 = false ;
4657     PyObject * obj0 = 0 ;
4658     PyObject * obj1 = 0 ;
4659     PyObject * obj2 = 0 ;
4660     char *kwnames[] = {
4661         (char *) "self",(char *) "name",(char *) "type", NULL
4662     };
4663
4664     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Bitmap_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
4665     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4666     if (SWIG_arg_fail(1)) SWIG_fail;
4667     {
4668         arg2 = wxString_in_helper(obj1);
4669         if (arg2 == NULL) SWIG_fail;
4670         temp2 = true;
4671     }
4672     {
4673         arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4674         if (SWIG_arg_fail(3)) SWIG_fail;
4675     }
4676     {
4677         PyThreadState* __tstate = wxPyBeginAllowThreads();
4678         result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
4679
4680         wxPyEndAllowThreads(__tstate);
4681         if (PyErr_Occurred()) SWIG_fail;
4682     }
4683     {
4684         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4685     }
4686     {
4687         if (temp2)
4688         delete arg2;
4689     }
4690     return resultobj;
4691     fail:
4692     {
4693         if (temp2)
4694         delete arg2;
4695     }
4696     return NULL;
4697 }
4698
4699
4700 static PyObject *_wrap_Bitmap_GetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
4701     PyObject *resultobj;
4702     wxBitmap *arg1 = (wxBitmap *) 0 ;
4703     wxPalette *result;
4704     PyObject * obj0 = 0 ;
4705     char *kwnames[] = {
4706         (char *) "self", NULL
4707     };
4708
4709     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetPalette",kwnames,&obj0)) goto fail;
4710     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4711     if (SWIG_arg_fail(1)) SWIG_fail;
4712     {
4713         PyThreadState* __tstate = wxPyBeginAllowThreads();
4714         result = (wxPalette *)((wxBitmap const *)arg1)->GetPalette();
4715
4716         wxPyEndAllowThreads(__tstate);
4717         if (PyErr_Occurred()) SWIG_fail;
4718     }
4719     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 0);
4720     return resultobj;
4721     fail:
4722     return NULL;
4723 }
4724
4725
4726 static PyObject *_wrap_Bitmap_SetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
4727     PyObject *resultobj;
4728     wxBitmap *arg1 = (wxBitmap *) 0 ;
4729     wxPalette *arg2 = 0 ;
4730     PyObject * obj0 = 0 ;
4731     PyObject * obj1 = 0 ;
4732     char *kwnames[] = {
4733         (char *) "self",(char *) "palette", NULL
4734     };
4735
4736     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetPalette",kwnames,&obj0,&obj1)) goto fail;
4737     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4738     if (SWIG_arg_fail(1)) SWIG_fail;
4739     {
4740         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
4741         if (SWIG_arg_fail(2)) SWIG_fail;
4742         if (arg2 == NULL) {
4743             SWIG_null_ref("wxPalette");
4744         }
4745         if (SWIG_arg_fail(2)) SWIG_fail;
4746     }
4747     {
4748         PyThreadState* __tstate = wxPyBeginAllowThreads();
4749         (arg1)->SetPalette((wxPalette const &)*arg2);
4750
4751         wxPyEndAllowThreads(__tstate);
4752         if (PyErr_Occurred()) SWIG_fail;
4753     }
4754     Py_INCREF(Py_None); resultobj = Py_None;
4755     return resultobj;
4756     fail:
4757     return NULL;
4758 }
4759
4760
4761 static PyObject *_wrap_Bitmap_CopyFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4762     PyObject *resultobj;
4763     wxBitmap *arg1 = (wxBitmap *) 0 ;
4764     wxIcon *arg2 = 0 ;
4765     bool result;
4766     PyObject * obj0 = 0 ;
4767     PyObject * obj1 = 0 ;
4768     char *kwnames[] = {
4769         (char *) "self",(char *) "icon", NULL
4770     };
4771
4772     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromIcon",kwnames,&obj0,&obj1)) goto fail;
4773     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4774     if (SWIG_arg_fail(1)) SWIG_fail;
4775     {
4776         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4777         if (SWIG_arg_fail(2)) SWIG_fail;
4778         if (arg2 == NULL) {
4779             SWIG_null_ref("wxIcon");
4780         }
4781         if (SWIG_arg_fail(2)) SWIG_fail;
4782     }
4783     {
4784         PyThreadState* __tstate = wxPyBeginAllowThreads();
4785         result = (bool)(arg1)->CopyFromIcon((wxIcon const &)*arg2);
4786
4787         wxPyEndAllowThreads(__tstate);
4788         if (PyErr_Occurred()) SWIG_fail;
4789     }
4790     {
4791         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4792     }
4793     return resultobj;
4794     fail:
4795     return NULL;
4796 }
4797
4798
4799 static PyObject *_wrap_Bitmap_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4800     PyObject *resultobj;
4801     wxBitmap *arg1 = (wxBitmap *) 0 ;
4802     int arg2 ;
4803     PyObject * obj0 = 0 ;
4804     PyObject * obj1 = 0 ;
4805     char *kwnames[] = {
4806         (char *) "self",(char *) "height", NULL
4807     };
4808
4809     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHeight",kwnames,&obj0,&obj1)) goto fail;
4810     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4811     if (SWIG_arg_fail(1)) SWIG_fail;
4812     {
4813         arg2 = (int)(SWIG_As_int(obj1));
4814         if (SWIG_arg_fail(2)) SWIG_fail;
4815     }
4816     {
4817         PyThreadState* __tstate = wxPyBeginAllowThreads();
4818         (arg1)->SetHeight(arg2);
4819
4820         wxPyEndAllowThreads(__tstate);
4821         if (PyErr_Occurred()) SWIG_fail;
4822     }
4823     Py_INCREF(Py_None); resultobj = Py_None;
4824     return resultobj;
4825     fail:
4826     return NULL;
4827 }
4828
4829
4830 static PyObject *_wrap_Bitmap_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4831     PyObject *resultobj;
4832     wxBitmap *arg1 = (wxBitmap *) 0 ;
4833     int arg2 ;
4834     PyObject * obj0 = 0 ;
4835     PyObject * obj1 = 0 ;
4836     char *kwnames[] = {
4837         (char *) "self",(char *) "width", NULL
4838     };
4839
4840     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetWidth",kwnames,&obj0,&obj1)) goto fail;
4841     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4842     if (SWIG_arg_fail(1)) SWIG_fail;
4843     {
4844         arg2 = (int)(SWIG_As_int(obj1));
4845         if (SWIG_arg_fail(2)) SWIG_fail;
4846     }
4847     {
4848         PyThreadState* __tstate = wxPyBeginAllowThreads();
4849         (arg1)->SetWidth(arg2);
4850
4851         wxPyEndAllowThreads(__tstate);
4852         if (PyErr_Occurred()) SWIG_fail;
4853     }
4854     Py_INCREF(Py_None); resultobj = Py_None;
4855     return resultobj;
4856     fail:
4857     return NULL;
4858 }
4859
4860
4861 static PyObject *_wrap_Bitmap_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4862     PyObject *resultobj;
4863     wxBitmap *arg1 = (wxBitmap *) 0 ;
4864     int arg2 ;
4865     PyObject * obj0 = 0 ;
4866     PyObject * obj1 = 0 ;
4867     char *kwnames[] = {
4868         (char *) "self",(char *) "depth", NULL
4869     };
4870
4871     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetDepth",kwnames,&obj0,&obj1)) goto fail;
4872     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4873     if (SWIG_arg_fail(1)) SWIG_fail;
4874     {
4875         arg2 = (int)(SWIG_As_int(obj1));
4876         if (SWIG_arg_fail(2)) SWIG_fail;
4877     }
4878     {
4879         PyThreadState* __tstate = wxPyBeginAllowThreads();
4880         (arg1)->SetDepth(arg2);
4881
4882         wxPyEndAllowThreads(__tstate);
4883         if (PyErr_Occurred()) SWIG_fail;
4884     }
4885     Py_INCREF(Py_None); resultobj = Py_None;
4886     return resultobj;
4887     fail:
4888     return NULL;
4889 }
4890
4891
4892 static PyObject *_wrap_Bitmap_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4893     PyObject *resultobj;
4894     wxBitmap *arg1 = (wxBitmap *) 0 ;
4895     wxSize *arg2 = 0 ;
4896     wxSize temp2 ;
4897     PyObject * obj0 = 0 ;
4898     PyObject * obj1 = 0 ;
4899     char *kwnames[] = {
4900         (char *) "self",(char *) "size", NULL
4901     };
4902
4903     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetSize",kwnames,&obj0,&obj1)) goto fail;
4904     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4905     if (SWIG_arg_fail(1)) SWIG_fail;
4906     {
4907         arg2 = &temp2;
4908         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4909     }
4910     {
4911         PyThreadState* __tstate = wxPyBeginAllowThreads();
4912         wxBitmap_SetSize(arg1,(wxSize const &)*arg2);
4913
4914         wxPyEndAllowThreads(__tstate);
4915         if (PyErr_Occurred()) SWIG_fail;
4916     }
4917     Py_INCREF(Py_None); resultobj = Py_None;
4918     return resultobj;
4919     fail:
4920     return NULL;
4921 }
4922
4923
4924 static PyObject *_wrap_Bitmap_CopyFromCursor(PyObject *, PyObject *args, PyObject *kwargs) {
4925     PyObject *resultobj;
4926     wxBitmap *arg1 = (wxBitmap *) 0 ;
4927     wxCursor *arg2 = 0 ;
4928     bool result;
4929     PyObject * obj0 = 0 ;
4930     PyObject * obj1 = 0 ;
4931     char *kwnames[] = {
4932         (char *) "self",(char *) "cursor", NULL
4933     };
4934
4935     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromCursor",kwnames,&obj0,&obj1)) goto fail;
4936     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4937     if (SWIG_arg_fail(1)) SWIG_fail;
4938     {
4939         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
4940         if (SWIG_arg_fail(2)) SWIG_fail;
4941         if (arg2 == NULL) {
4942             SWIG_null_ref("wxCursor");
4943         }
4944         if (SWIG_arg_fail(2)) SWIG_fail;
4945     }
4946     {
4947         PyThreadState* __tstate = wxPyBeginAllowThreads();
4948         result = (bool)(arg1)->CopyFromCursor((wxCursor const &)*arg2);
4949
4950         wxPyEndAllowThreads(__tstate);
4951         if (PyErr_Occurred()) SWIG_fail;
4952     }
4953     {
4954         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4955     }
4956     return resultobj;
4957     fail:
4958     return NULL;
4959 }
4960
4961
4962 static PyObject *_wrap_Bitmap_GetQuality(PyObject *, PyObject *args, PyObject *kwargs) {
4963     PyObject *resultobj;
4964     wxBitmap *arg1 = (wxBitmap *) 0 ;
4965     int result;
4966     PyObject * obj0 = 0 ;
4967     char *kwnames[] = {
4968         (char *) "self", NULL
4969     };
4970
4971     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetQuality",kwnames,&obj0)) goto fail;
4972     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4973     if (SWIG_arg_fail(1)) SWIG_fail;
4974     {
4975         PyThreadState* __tstate = wxPyBeginAllowThreads();
4976         result = (int)(arg1)->GetQuality();
4977
4978         wxPyEndAllowThreads(__tstate);
4979         if (PyErr_Occurred()) SWIG_fail;
4980     }
4981     {
4982         resultobj = SWIG_From_int((int)(result));
4983     }
4984     return resultobj;
4985     fail:
4986     return NULL;
4987 }
4988
4989
4990 static PyObject *_wrap_Bitmap_SetQuality(PyObject *, PyObject *args, PyObject *kwargs) {
4991     PyObject *resultobj;
4992     wxBitmap *arg1 = (wxBitmap *) 0 ;
4993     int arg2 ;
4994     PyObject * obj0 = 0 ;
4995     PyObject * obj1 = 0 ;
4996     char *kwnames[] = {
4997         (char *) "self",(char *) "q", NULL
4998     };
4999
5000     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetQuality",kwnames,&obj0,&obj1)) goto fail;
5001     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5002     if (SWIG_arg_fail(1)) SWIG_fail;
5003     {
5004         arg2 = (int)(SWIG_As_int(obj1));
5005         if (SWIG_arg_fail(2)) SWIG_fail;
5006     }
5007     {
5008         PyThreadState* __tstate = wxPyBeginAllowThreads();
5009         (arg1)->SetQuality(arg2);
5010
5011         wxPyEndAllowThreads(__tstate);
5012         if (PyErr_Occurred()) SWIG_fail;
5013     }
5014     Py_INCREF(Py_None); resultobj = Py_None;
5015     return resultobj;
5016     fail:
5017     return NULL;
5018 }
5019
5020
5021 static PyObject *_wrap_Bitmap___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5022     PyObject *resultobj;
5023     wxBitmap *arg1 = (wxBitmap *) 0 ;
5024     wxBitmap *arg2 = (wxBitmap *) 0 ;
5025     bool result;
5026     PyObject * obj0 = 0 ;
5027     PyObject * obj1 = 0 ;
5028     char *kwnames[] = {
5029         (char *) "self",(char *) "other", NULL
5030     };
5031
5032     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___eq__",kwnames,&obj0,&obj1)) goto fail;
5033     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5034     if (SWIG_arg_fail(1)) SWIG_fail;
5035     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5036     if (SWIG_arg_fail(2)) SWIG_fail;
5037     {
5038         PyThreadState* __tstate = wxPyBeginAllowThreads();
5039         result = (bool)wxBitmap___eq__(arg1,(wxBitmap const *)arg2);
5040
5041         wxPyEndAllowThreads(__tstate);
5042         if (PyErr_Occurred()) SWIG_fail;
5043     }
5044     {
5045         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5046     }
5047     return resultobj;
5048     fail:
5049     return NULL;
5050 }
5051
5052
5053 static PyObject *_wrap_Bitmap___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
5054     PyObject *resultobj;
5055     wxBitmap *arg1 = (wxBitmap *) 0 ;
5056     wxBitmap *arg2 = (wxBitmap *) 0 ;
5057     bool result;
5058     PyObject * obj0 = 0 ;
5059     PyObject * obj1 = 0 ;
5060     char *kwnames[] = {
5061         (char *) "self",(char *) "other", NULL
5062     };
5063
5064     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___ne__",kwnames,&obj0,&obj1)) goto fail;
5065     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5066     if (SWIG_arg_fail(1)) SWIG_fail;
5067     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5068     if (SWIG_arg_fail(2)) SWIG_fail;
5069     {
5070         PyThreadState* __tstate = wxPyBeginAllowThreads();
5071         result = (bool)wxBitmap___ne__(arg1,(wxBitmap const *)arg2);
5072
5073         wxPyEndAllowThreads(__tstate);
5074         if (PyErr_Occurred()) SWIG_fail;
5075     }
5076     {
5077         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5078     }
5079     return resultobj;
5080     fail:
5081     return NULL;
5082 }
5083
5084
5085 static PyObject * Bitmap_swigregister(PyObject *, PyObject *args) {
5086     PyObject *obj;
5087     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5088     SWIG_TypeClientData(SWIGTYPE_p_wxBitmap, obj);
5089     Py_INCREF(obj);
5090     return Py_BuildValue((char *)"");
5091 }
5092 static PyObject *_wrap_new_Mask(PyObject *, PyObject *args, PyObject *kwargs) {
5093     PyObject *resultobj;
5094     wxBitmap *arg1 = 0 ;
5095     wxColour const &arg2_defvalue = wxNullColour ;
5096     wxColour *arg2 = (wxColour *) &arg2_defvalue ;
5097     wxMask *result;
5098     wxColour temp2 ;
5099     PyObject * obj0 = 0 ;
5100     PyObject * obj1 = 0 ;
5101     char *kwnames[] = {
5102         (char *) "bitmap",(char *) "colour", NULL
5103     };
5104
5105     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Mask",kwnames,&obj0,&obj1)) goto fail;
5106     {
5107         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5108         if (SWIG_arg_fail(1)) SWIG_fail;
5109         if (arg1 == NULL) {
5110             SWIG_null_ref("wxBitmap");
5111         }
5112         if (SWIG_arg_fail(1)) SWIG_fail;
5113     }
5114     if (obj1) {
5115         {
5116             arg2 = &temp2;
5117             if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5118         }
5119     }
5120     {
5121         if (!wxPyCheckForApp()) SWIG_fail;
5122         PyThreadState* __tstate = wxPyBeginAllowThreads();
5123         result = (wxMask *)new_wxMask((wxBitmap const &)*arg1,(wxColour const &)*arg2);
5124
5125         wxPyEndAllowThreads(__tstate);
5126         if (PyErr_Occurred()) SWIG_fail;
5127     }
5128     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 1);
5129     return resultobj;
5130     fail:
5131     return NULL;
5132 }
5133
5134
5135 static PyObject * Mask_swigregister(PyObject *, PyObject *args) {
5136     PyObject *obj;
5137     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5138     SWIG_TypeClientData(SWIGTYPE_p_wxMask, obj);
5139     Py_INCREF(obj);
5140     return Py_BuildValue((char *)"");
5141 }
5142 static PyObject *_wrap_new_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
5143     PyObject *resultobj;
5144     wxString *arg1 = 0 ;
5145     wxBitmapType arg2 ;
5146     int arg3 = (int) -1 ;
5147     int arg4 = (int) -1 ;
5148     wxIcon *result;
5149     bool temp1 = false ;
5150     PyObject * obj0 = 0 ;
5151     PyObject * obj1 = 0 ;
5152     PyObject * obj2 = 0 ;
5153     PyObject * obj3 = 0 ;
5154     char *kwnames[] = {
5155         (char *) "name",(char *) "type",(char *) "desiredWidth",(char *) "desiredHeight", NULL
5156     };
5157
5158     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Icon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5159     {
5160         arg1 = wxString_in_helper(obj0);
5161         if (arg1 == NULL) SWIG_fail;
5162         temp1 = true;
5163     }
5164     {
5165         arg2 = (wxBitmapType)(SWIG_As_int(obj1));
5166         if (SWIG_arg_fail(2)) SWIG_fail;
5167     }
5168     if (obj2) {
5169         {
5170             arg3 = (int)(SWIG_As_int(obj2));
5171             if (SWIG_arg_fail(3)) SWIG_fail;
5172         }
5173     }
5174     if (obj3) {
5175         {
5176             arg4 = (int)(SWIG_As_int(obj3));
5177             if (SWIG_arg_fail(4)) SWIG_fail;
5178         }
5179     }
5180     {
5181         if (!wxPyCheckForApp()) SWIG_fail;
5182         PyThreadState* __tstate = wxPyBeginAllowThreads();
5183         result = (wxIcon *)new wxIcon((wxString const &)*arg1,(wxBitmapType )arg2,arg3,arg4);
5184
5185         wxPyEndAllowThreads(__tstate);
5186         if (PyErr_Occurred()) SWIG_fail;
5187     }
5188     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5189     {
5190         if (temp1)
5191         delete arg1;
5192     }
5193     return resultobj;
5194     fail:
5195     {
5196         if (temp1)
5197         delete arg1;
5198     }
5199     return NULL;
5200 }
5201
5202
5203 static PyObject *_wrap_delete_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
5204     PyObject *resultobj;
5205     wxIcon *arg1 = (wxIcon *) 0 ;
5206     PyObject * obj0 = 0 ;
5207     char *kwnames[] = {
5208         (char *) "self", NULL
5209     };
5210
5211     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Icon",kwnames,&obj0)) goto fail;
5212     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5213     if (SWIG_arg_fail(1)) SWIG_fail;
5214     {
5215         PyThreadState* __tstate = wxPyBeginAllowThreads();
5216         delete arg1;
5217
5218         wxPyEndAllowThreads(__tstate);
5219         if (PyErr_Occurred()) SWIG_fail;
5220     }
5221     Py_INCREF(Py_None); resultobj = Py_None;
5222     return resultobj;
5223     fail:
5224     return NULL;
5225 }
5226
5227
5228 static PyObject *_wrap_new_EmptyIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5229     PyObject *resultobj;
5230     wxIcon *result;
5231     char *kwnames[] = {
5232         NULL
5233     };
5234
5235     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EmptyIcon",kwnames)) goto fail;
5236     {
5237         if (!wxPyCheckForApp()) SWIG_fail;
5238         PyThreadState* __tstate = wxPyBeginAllowThreads();
5239         result = (wxIcon *)new wxIcon();
5240
5241         wxPyEndAllowThreads(__tstate);
5242         if (PyErr_Occurred()) SWIG_fail;
5243     }
5244     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5245     return resultobj;
5246     fail:
5247     return NULL;
5248 }
5249
5250
5251 static PyObject *_wrap_new_IconFromLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5252     PyObject *resultobj;
5253     wxIconLocation *arg1 = 0 ;
5254     wxIcon *result;
5255     PyObject * obj0 = 0 ;
5256     char *kwnames[] = {
5257         (char *) "loc", NULL
5258     };
5259
5260     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromLocation",kwnames,&obj0)) goto fail;
5261     {
5262         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5263         if (SWIG_arg_fail(1)) SWIG_fail;
5264         if (arg1 == NULL) {
5265             SWIG_null_ref("wxIconLocation");
5266         }
5267         if (SWIG_arg_fail(1)) SWIG_fail;
5268     }
5269     {
5270         if (!wxPyCheckForApp()) SWIG_fail;
5271         PyThreadState* __tstate = wxPyBeginAllowThreads();
5272         result = (wxIcon *)new wxIcon((wxIconLocation const &)*arg1);
5273
5274         wxPyEndAllowThreads(__tstate);
5275         if (PyErr_Occurred()) SWIG_fail;
5276     }
5277     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5278     return resultobj;
5279     fail:
5280     return NULL;
5281 }
5282
5283
5284 static PyObject *_wrap_new_IconFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5285     PyObject *resultobj;
5286     wxBitmap *arg1 = 0 ;
5287     wxIcon *result;
5288     PyObject * obj0 = 0 ;
5289     char *kwnames[] = {
5290         (char *) "bmp", NULL
5291     };
5292
5293     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromBitmap",kwnames,&obj0)) goto fail;
5294     {
5295         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5296         if (SWIG_arg_fail(1)) SWIG_fail;
5297         if (arg1 == NULL) {
5298             SWIG_null_ref("wxBitmap");
5299         }
5300         if (SWIG_arg_fail(1)) SWIG_fail;
5301     }
5302     {
5303         if (!wxPyCheckForApp()) SWIG_fail;
5304         PyThreadState* __tstate = wxPyBeginAllowThreads();
5305         result = (wxIcon *)new_wxIcon((wxBitmap const &)*arg1);
5306
5307         wxPyEndAllowThreads(__tstate);
5308         if (PyErr_Occurred()) SWIG_fail;
5309     }
5310     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5311     return resultobj;
5312     fail:
5313     return NULL;
5314 }
5315
5316
5317 static PyObject *_wrap_new_IconFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
5318     PyObject *resultobj;
5319     PyObject *arg1 = (PyObject *) 0 ;
5320     wxIcon *result;
5321     PyObject * obj0 = 0 ;
5322     char *kwnames[] = {
5323         (char *) "listOfStrings", NULL
5324     };
5325
5326     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromXPMData",kwnames,&obj0)) goto fail;
5327     arg1 = obj0;
5328     {
5329         if (!wxPyCheckForApp()) SWIG_fail;
5330         PyThreadState* __tstate = wxPyBeginAllowThreads();
5331         result = (wxIcon *)new_wxIcon(arg1);
5332
5333         wxPyEndAllowThreads(__tstate);
5334         if (PyErr_Occurred()) SWIG_fail;
5335     }
5336     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5337     return resultobj;
5338     fail:
5339     return NULL;
5340 }
5341
5342
5343 static PyObject *_wrap_Icon_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
5344     PyObject *resultobj;
5345     wxIcon *arg1 = (wxIcon *) 0 ;
5346     wxString *arg2 = 0 ;
5347     wxBitmapType arg3 ;
5348     bool result;
5349     bool temp2 = false ;
5350     PyObject * obj0 = 0 ;
5351     PyObject * obj1 = 0 ;
5352     PyObject * obj2 = 0 ;
5353     char *kwnames[] = {
5354         (char *) "self",(char *) "name",(char *) "type", NULL
5355     };
5356
5357     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Icon_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
5358     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5359     if (SWIG_arg_fail(1)) SWIG_fail;
5360     {
5361         arg2 = wxString_in_helper(obj1);
5362         if (arg2 == NULL) SWIG_fail;
5363         temp2 = true;
5364     }
5365     {
5366         arg3 = (wxBitmapType)(SWIG_As_int(obj2));
5367         if (SWIG_arg_fail(3)) SWIG_fail;
5368     }
5369     {
5370         PyThreadState* __tstate = wxPyBeginAllowThreads();
5371         result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
5372
5373         wxPyEndAllowThreads(__tstate);
5374         if (PyErr_Occurred()) SWIG_fail;
5375     }
5376     {
5377         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5378     }
5379     {
5380         if (temp2)
5381         delete arg2;
5382     }
5383     return resultobj;
5384     fail:
5385     {
5386         if (temp2)
5387         delete arg2;
5388     }
5389     return NULL;
5390 }
5391
5392
5393 static PyObject *_wrap_Icon_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
5394     PyObject *resultobj;
5395     wxIcon *arg1 = (wxIcon *) 0 ;
5396     long result;
5397     PyObject * obj0 = 0 ;
5398     char *kwnames[] = {
5399         (char *) "self", NULL
5400     };
5401
5402     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetHandle",kwnames,&obj0)) goto fail;
5403     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5404     if (SWIG_arg_fail(1)) SWIG_fail;
5405     {
5406         PyThreadState* __tstate = wxPyBeginAllowThreads();
5407         result = (long)(arg1)->GetHandle();
5408
5409         wxPyEndAllowThreads(__tstate);
5410         if (PyErr_Occurred()) SWIG_fail;
5411     }
5412     {
5413         resultobj = SWIG_From_long((long)(result));
5414     }
5415     return resultobj;
5416     fail:
5417     return NULL;
5418 }
5419
5420
5421 static PyObject *_wrap_Icon_SetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
5422     PyObject *resultobj;
5423     wxIcon *arg1 = (wxIcon *) 0 ;
5424     long arg2 ;
5425     PyObject * obj0 = 0 ;
5426     PyObject * obj1 = 0 ;
5427     char *kwnames[] = {
5428         (char *) "self",(char *) "handle", NULL
5429     };
5430
5431     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHandle",kwnames,&obj0,&obj1)) goto fail;
5432     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5433     if (SWIG_arg_fail(1)) SWIG_fail;
5434     {
5435         arg2 = (long)(SWIG_As_long(obj1));
5436         if (SWIG_arg_fail(2)) SWIG_fail;
5437     }
5438     {
5439         PyThreadState* __tstate = wxPyBeginAllowThreads();
5440         wxIcon_SetHandle(arg1,arg2);
5441
5442         wxPyEndAllowThreads(__tstate);
5443         if (PyErr_Occurred()) SWIG_fail;
5444     }
5445     Py_INCREF(Py_None); resultobj = Py_None;
5446     return resultobj;
5447     fail:
5448     return NULL;
5449 }
5450
5451
5452 static PyObject *_wrap_Icon_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
5453     PyObject *resultobj;
5454     wxIcon *arg1 = (wxIcon *) 0 ;
5455     bool result;
5456     PyObject * obj0 = 0 ;
5457     char *kwnames[] = {
5458         (char *) "self", NULL
5459     };
5460
5461     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_Ok",kwnames,&obj0)) goto fail;
5462     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5463     if (SWIG_arg_fail(1)) SWIG_fail;
5464     {
5465         PyThreadState* __tstate = wxPyBeginAllowThreads();
5466         result = (bool)(arg1)->Ok();
5467
5468         wxPyEndAllowThreads(__tstate);
5469         if (PyErr_Occurred()) SWIG_fail;
5470     }
5471     {
5472         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5473     }
5474     return resultobj;
5475     fail:
5476     return NULL;
5477 }
5478
5479
5480 static PyObject *_wrap_Icon_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5481     PyObject *resultobj;
5482     wxIcon *arg1 = (wxIcon *) 0 ;
5483     int result;
5484     PyObject * obj0 = 0 ;
5485     char *kwnames[] = {
5486         (char *) "self", NULL
5487     };
5488
5489     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetWidth",kwnames,&obj0)) goto fail;
5490     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5491     if (SWIG_arg_fail(1)) SWIG_fail;
5492     {
5493         PyThreadState* __tstate = wxPyBeginAllowThreads();
5494         result = (int)(arg1)->GetWidth();
5495
5496         wxPyEndAllowThreads(__tstate);
5497         if (PyErr_Occurred()) SWIG_fail;
5498     }
5499     {
5500         resultobj = SWIG_From_int((int)(result));
5501     }
5502     return resultobj;
5503     fail:
5504     return NULL;
5505 }
5506
5507
5508 static PyObject *_wrap_Icon_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5509     PyObject *resultobj;
5510     wxIcon *arg1 = (wxIcon *) 0 ;
5511     int result;
5512     PyObject * obj0 = 0 ;
5513     char *kwnames[] = {
5514         (char *) "self", NULL
5515     };
5516
5517     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetHeight",kwnames,&obj0)) goto fail;
5518     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5519     if (SWIG_arg_fail(1)) SWIG_fail;
5520     {
5521         PyThreadState* __tstate = wxPyBeginAllowThreads();
5522         result = (int)(arg1)->GetHeight();
5523
5524         wxPyEndAllowThreads(__tstate);
5525         if (PyErr_Occurred()) SWIG_fail;
5526     }
5527     {
5528         resultobj = SWIG_From_int((int)(result));
5529     }
5530     return resultobj;
5531     fail:
5532     return NULL;
5533 }
5534
5535
5536 static PyObject *_wrap_Icon_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5537     PyObject *resultobj;
5538     wxIcon *arg1 = (wxIcon *) 0 ;
5539     int result;
5540     PyObject * obj0 = 0 ;
5541     char *kwnames[] = {
5542         (char *) "self", NULL
5543     };
5544
5545     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetDepth",kwnames,&obj0)) goto fail;
5546     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5547     if (SWIG_arg_fail(1)) SWIG_fail;
5548     {
5549         PyThreadState* __tstate = wxPyBeginAllowThreads();
5550         result = (int)(arg1)->GetDepth();
5551
5552         wxPyEndAllowThreads(__tstate);
5553         if (PyErr_Occurred()) SWIG_fail;
5554     }
5555     {
5556         resultobj = SWIG_From_int((int)(result));
5557     }
5558     return resultobj;
5559     fail:
5560     return NULL;
5561 }
5562
5563
5564 static PyObject *_wrap_Icon_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5565     PyObject *resultobj;
5566     wxIcon *arg1 = (wxIcon *) 0 ;
5567     int arg2 ;
5568     PyObject * obj0 = 0 ;
5569     PyObject * obj1 = 0 ;
5570     char *kwnames[] = {
5571         (char *) "self",(char *) "w", NULL
5572     };
5573
5574     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5575     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5576     if (SWIG_arg_fail(1)) SWIG_fail;
5577     {
5578         arg2 = (int)(SWIG_As_int(obj1));
5579         if (SWIG_arg_fail(2)) SWIG_fail;
5580     }
5581     {
5582         PyThreadState* __tstate = wxPyBeginAllowThreads();
5583         (arg1)->SetWidth(arg2);
5584
5585         wxPyEndAllowThreads(__tstate);
5586         if (PyErr_Occurred()) SWIG_fail;
5587     }
5588     Py_INCREF(Py_None); resultobj = Py_None;
5589     return resultobj;
5590     fail:
5591     return NULL;
5592 }
5593
5594
5595 static PyObject *_wrap_Icon_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5596     PyObject *resultobj;
5597     wxIcon *arg1 = (wxIcon *) 0 ;
5598     int arg2 ;
5599     PyObject * obj0 = 0 ;
5600     PyObject * obj1 = 0 ;
5601     char *kwnames[] = {
5602         (char *) "self",(char *) "h", NULL
5603     };
5604
5605     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5606     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5607     if (SWIG_arg_fail(1)) SWIG_fail;
5608     {
5609         arg2 = (int)(SWIG_As_int(obj1));
5610         if (SWIG_arg_fail(2)) SWIG_fail;
5611     }
5612     {
5613         PyThreadState* __tstate = wxPyBeginAllowThreads();
5614         (arg1)->SetHeight(arg2);
5615
5616         wxPyEndAllowThreads(__tstate);
5617         if (PyErr_Occurred()) SWIG_fail;
5618     }
5619     Py_INCREF(Py_None); resultobj = Py_None;
5620     return resultobj;
5621     fail:
5622     return NULL;
5623 }
5624
5625
5626 static PyObject *_wrap_Icon_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5627     PyObject *resultobj;
5628     wxIcon *arg1 = (wxIcon *) 0 ;
5629     int arg2 ;
5630     PyObject * obj0 = 0 ;
5631     PyObject * obj1 = 0 ;
5632     char *kwnames[] = {
5633         (char *) "self",(char *) "d", NULL
5634     };
5635
5636     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetDepth",kwnames,&obj0,&obj1)) goto fail;
5637     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5638     if (SWIG_arg_fail(1)) SWIG_fail;
5639     {
5640         arg2 = (int)(SWIG_As_int(obj1));
5641         if (SWIG_arg_fail(2)) SWIG_fail;
5642     }
5643     {
5644         PyThreadState* __tstate = wxPyBeginAllowThreads();
5645         (arg1)->SetDepth(arg2);
5646
5647         wxPyEndAllowThreads(__tstate);
5648         if (PyErr_Occurred()) SWIG_fail;
5649     }
5650     Py_INCREF(Py_None); resultobj = Py_None;
5651     return resultobj;
5652     fail:
5653     return NULL;
5654 }
5655
5656
5657 static PyObject *_wrap_Icon_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5658     PyObject *resultobj;
5659     wxIcon *arg1 = (wxIcon *) 0 ;
5660     wxSize *arg2 = 0 ;
5661     wxSize temp2 ;
5662     PyObject * obj0 = 0 ;
5663     PyObject * obj1 = 0 ;
5664     char *kwnames[] = {
5665         (char *) "self",(char *) "size", NULL
5666     };
5667
5668     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetSize",kwnames,&obj0,&obj1)) goto fail;
5669     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5670     if (SWIG_arg_fail(1)) SWIG_fail;
5671     {
5672         arg2 = &temp2;
5673         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5674     }
5675     {
5676         PyThreadState* __tstate = wxPyBeginAllowThreads();
5677         (arg1)->SetSize((wxSize const &)*arg2);
5678
5679         wxPyEndAllowThreads(__tstate);
5680         if (PyErr_Occurred()) SWIG_fail;
5681     }
5682     Py_INCREF(Py_None); resultobj = Py_None;
5683     return resultobj;
5684     fail:
5685     return NULL;
5686 }
5687
5688
5689 static PyObject *_wrap_Icon_CopyFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5690     PyObject *resultobj;
5691     wxIcon *arg1 = (wxIcon *) 0 ;
5692     wxBitmap *arg2 = 0 ;
5693     PyObject * obj0 = 0 ;
5694     PyObject * obj1 = 0 ;
5695     char *kwnames[] = {
5696         (char *) "self",(char *) "bmp", NULL
5697     };
5698
5699     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_CopyFromBitmap",kwnames,&obj0,&obj1)) goto fail;
5700     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5701     if (SWIG_arg_fail(1)) SWIG_fail;
5702     {
5703         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5704         if (SWIG_arg_fail(2)) SWIG_fail;
5705         if (arg2 == NULL) {
5706             SWIG_null_ref("wxBitmap");
5707         }
5708         if (SWIG_arg_fail(2)) SWIG_fail;
5709     }
5710     {
5711         PyThreadState* __tstate = wxPyBeginAllowThreads();
5712         (arg1)->CopyFromBitmap((wxBitmap const &)*arg2);
5713
5714         wxPyEndAllowThreads(__tstate);
5715         if (PyErr_Occurred()) SWIG_fail;
5716     }
5717     Py_INCREF(Py_None); resultobj = Py_None;
5718     return resultobj;
5719     fail:
5720     return NULL;
5721 }
5722
5723
5724 static PyObject * Icon_swigregister(PyObject *, PyObject *args) {
5725     PyObject *obj;
5726     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5727     SWIG_TypeClientData(SWIGTYPE_p_wxIcon, obj);
5728     Py_INCREF(obj);
5729     return Py_BuildValue((char *)"");
5730 }
5731 static PyObject *_wrap_new_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5732     PyObject *resultobj;
5733     wxString *arg1 = (wxString *) &wxPyEmptyString ;
5734     int arg2 = (int) 0 ;
5735     wxIconLocation *result;
5736     bool temp1 = false ;
5737     PyObject * obj0 = 0 ;
5738     PyObject * obj1 = 0 ;
5739     char *kwnames[] = {
5740         (char *) "filename",(char *) "num", NULL
5741     };
5742
5743     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconLocation",kwnames,&obj0,&obj1)) goto fail;
5744     if (obj0) {
5745         {
5746             arg1 = wxString_in_helper(obj0);
5747             if (arg1 == NULL) SWIG_fail;
5748             temp1 = true;
5749         }
5750     }
5751     if (obj1) {
5752         {
5753             arg2 = (int)(SWIG_As_int(obj1));
5754             if (SWIG_arg_fail(2)) SWIG_fail;
5755         }
5756     }
5757     {
5758         PyThreadState* __tstate = wxPyBeginAllowThreads();
5759         result = (wxIconLocation *)new_wxIconLocation((wxString const *)arg1,arg2);
5760
5761         wxPyEndAllowThreads(__tstate);
5762         if (PyErr_Occurred()) SWIG_fail;
5763     }
5764     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconLocation, 1);
5765     {
5766         if (temp1)
5767         delete arg1;
5768     }
5769     return resultobj;
5770     fail:
5771     {
5772         if (temp1)
5773         delete arg1;
5774     }
5775     return NULL;
5776 }
5777
5778
5779 static PyObject *_wrap_delete_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5780     PyObject *resultobj;
5781     wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5782     PyObject * obj0 = 0 ;
5783     char *kwnames[] = {
5784         (char *) "self", NULL
5785     };
5786
5787     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconLocation",kwnames,&obj0)) goto fail;
5788     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5789     if (SWIG_arg_fail(1)) SWIG_fail;
5790     {
5791         PyThreadState* __tstate = wxPyBeginAllowThreads();
5792         delete arg1;
5793
5794         wxPyEndAllowThreads(__tstate);
5795         if (PyErr_Occurred()) SWIG_fail;
5796     }
5797     Py_INCREF(Py_None); resultobj = Py_None;
5798     return resultobj;
5799     fail:
5800     return NULL;
5801 }
5802
5803
5804 static PyObject *_wrap_IconLocation_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
5805     PyObject *resultobj;
5806     wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5807     bool result;
5808     PyObject * obj0 = 0 ;
5809     char *kwnames[] = {
5810         (char *) "self", NULL
5811     };
5812
5813     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_IsOk",kwnames,&obj0)) goto fail;
5814     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5815     if (SWIG_arg_fail(1)) SWIG_fail;
5816     {
5817         PyThreadState* __tstate = wxPyBeginAllowThreads();
5818         result = (bool)((wxIconLocation const *)arg1)->IsOk();
5819
5820         wxPyEndAllowThreads(__tstate);
5821         if (PyErr_Occurred()) SWIG_fail;
5822     }
5823     {
5824         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5825     }
5826     return resultobj;
5827     fail:
5828     return NULL;
5829 }
5830
5831
5832 static PyObject *_wrap_IconLocation_SetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5833     PyObject *resultobj;
5834     wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5835     wxString *arg2 = 0 ;
5836     bool temp2 = false ;
5837     PyObject * obj0 = 0 ;
5838     PyObject * obj1 = 0 ;
5839     char *kwnames[] = {
5840         (char *) "self",(char *) "filename", NULL
5841     };
5842
5843     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetFileName",kwnames,&obj0,&obj1)) goto fail;
5844     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5845     if (SWIG_arg_fail(1)) SWIG_fail;
5846     {
5847         arg2 = wxString_in_helper(obj1);
5848         if (arg2 == NULL) SWIG_fail;
5849         temp2 = true;
5850     }
5851     {
5852         PyThreadState* __tstate = wxPyBeginAllowThreads();
5853         (arg1)->SetFileName((wxString const &)*arg2);
5854
5855         wxPyEndAllowThreads(__tstate);
5856         if (PyErr_Occurred()) SWIG_fail;
5857     }
5858     Py_INCREF(Py_None); resultobj = Py_None;
5859     {
5860         if (temp2)
5861         delete arg2;
5862     }
5863     return resultobj;
5864     fail:
5865     {
5866         if (temp2)
5867         delete arg2;
5868     }
5869     return NULL;
5870 }
5871
5872
5873 static PyObject *_wrap_IconLocation_GetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5874     PyObject *resultobj;
5875     wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5876     wxString *result;
5877     PyObject * obj0 = 0 ;
5878     char *kwnames[] = {
5879         (char *) "self", NULL
5880     };
5881
5882     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetFileName",kwnames,&obj0)) goto fail;
5883     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5884     if (SWIG_arg_fail(1)) SWIG_fail;
5885     {
5886         PyThreadState* __tstate = wxPyBeginAllowThreads();
5887         {
5888             wxString const &_result_ref = ((wxIconLocation const *)arg1)->GetFileName();
5889             result = (wxString *) &_result_ref;
5890         }
5891
5892         wxPyEndAllowThreads(__tstate);
5893         if (PyErr_Occurred()) SWIG_fail;
5894     }
5895     {
5896 #if wxUSE_UNICODE
5897         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
5898 #else
5899         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
5900 #endif
5901     }
5902     return resultobj;
5903     fail:
5904     return NULL;
5905 }
5906
5907
5908 static PyObject *_wrap_IconLocation_SetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5909     PyObject *resultobj;
5910     wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5911     int arg2 ;
5912     PyObject * obj0 = 0 ;
5913     PyObject * obj1 = 0 ;
5914     char *kwnames[] = {
5915         (char *) "self",(char *) "num", NULL
5916     };
5917
5918     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetIndex",kwnames,&obj0,&obj1)) goto fail;
5919     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5920     if (SWIG_arg_fail(1)) SWIG_fail;
5921     {
5922         arg2 = (int)(SWIG_As_int(obj1));
5923         if (SWIG_arg_fail(2)) SWIG_fail;
5924     }
5925     {
5926         PyThreadState* __tstate = wxPyBeginAllowThreads();
5927         wxIconLocation_SetIndex(arg1,arg2);
5928
5929         wxPyEndAllowThreads(__tstate);
5930         if (PyErr_Occurred()) SWIG_fail;
5931     }
5932     Py_INCREF(Py_None); resultobj = Py_None;
5933     return resultobj;
5934     fail:
5935     return NULL;
5936 }
5937
5938
5939 static PyObject *_wrap_IconLocation_GetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5940     PyObject *resultobj;
5941     wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5942     int result;
5943     PyObject * obj0 = 0 ;
5944     char *kwnames[] = {
5945         (char *) "self", NULL
5946     };
5947
5948     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetIndex",kwnames,&obj0)) goto fail;
5949     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5950     if (SWIG_arg_fail(1)) SWIG_fail;
5951     {
5952         PyThreadState* __tstate = wxPyBeginAllowThreads();
5953         result = (int)wxIconLocation_GetIndex(arg1);
5954
5955         wxPyEndAllowThreads(__tstate);
5956         if (PyErr_Occurred()) SWIG_fail;
5957     }
5958     {
5959         resultobj = SWIG_From_int((int)(result));
5960     }
5961     return resultobj;
5962     fail:
5963     return NULL;
5964 }
5965
5966
5967 static PyObject * IconLocation_swigregister(PyObject *, PyObject *args) {
5968     PyObject *obj;
5969     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5970     SWIG_TypeClientData(SWIGTYPE_p_wxIconLocation, obj);
5971     Py_INCREF(obj);
5972     return Py_BuildValue((char *)"");
5973 }
5974 static PyObject *_wrap_new_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5975     PyObject *resultobj;
5976     wxIconBundle *result;
5977     char *kwnames[] = {
5978         NULL
5979     };
5980
5981     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IconBundle",kwnames)) goto fail;
5982     {
5983         PyThreadState* __tstate = wxPyBeginAllowThreads();
5984         result = (wxIconBundle *)new wxIconBundle();
5985
5986         wxPyEndAllowThreads(__tstate);
5987         if (PyErr_Occurred()) SWIG_fail;
5988     }
5989     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5990     return resultobj;
5991     fail:
5992     return NULL;
5993 }
5994
5995
5996 static PyObject *_wrap_new_IconBundleFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5997     PyObject *resultobj;
5998     wxString *arg1 = 0 ;
5999     long arg2 ;
6000     wxIconBundle *result;
6001     bool temp1 = false ;
6002     PyObject * obj0 = 0 ;
6003     PyObject * obj1 = 0 ;
6004     char *kwnames[] = {
6005         (char *) "file",(char *) "type", NULL
6006     };
6007
6008     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_IconBundleFromFile",kwnames,&obj0,&obj1)) goto fail;
6009     {
6010         arg1 = wxString_in_helper(obj0);
6011         if (arg1 == NULL) SWIG_fail;
6012         temp1 = true;
6013     }
6014     {
6015         arg2 = (long)(SWIG_As_long(obj1));
6016         if (SWIG_arg_fail(2)) SWIG_fail;
6017     }
6018     {
6019         PyThreadState* __tstate = wxPyBeginAllowThreads();
6020         result = (wxIconBundle *)new wxIconBundle((wxString const &)*arg1,arg2);
6021
6022         wxPyEndAllowThreads(__tstate);
6023         if (PyErr_Occurred()) SWIG_fail;
6024     }
6025     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
6026     {
6027         if (temp1)
6028         delete arg1;
6029     }
6030     return resultobj;
6031     fail:
6032     {
6033         if (temp1)
6034         delete arg1;
6035     }
6036     return NULL;
6037 }
6038
6039
6040 static PyObject *_wrap_new_IconBundleFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
6041     PyObject *resultobj;
6042     wxIcon *arg1 = 0 ;
6043     wxIconBundle *result;
6044     PyObject * obj0 = 0 ;
6045     char *kwnames[] = {
6046         (char *) "icon", NULL
6047     };
6048
6049     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconBundleFromIcon",kwnames,&obj0)) goto fail;
6050     {
6051         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
6052         if (SWIG_arg_fail(1)) SWIG_fail;
6053         if (arg1 == NULL) {
6054             SWIG_null_ref("wxIcon");
6055         }
6056         if (SWIG_arg_fail(1)) SWIG_fail;
6057     }
6058     {
6059         PyThreadState* __tstate = wxPyBeginAllowThreads();
6060         result = (wxIconBundle *)new wxIconBundle((wxIcon const &)*arg1);
6061
6062         wxPyEndAllowThreads(__tstate);
6063         if (PyErr_Occurred()) SWIG_fail;
6064     }
6065     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
6066     return resultobj;
6067     fail:
6068     return NULL;
6069 }
6070
6071
6072 static PyObject *_wrap_delete_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
6073     PyObject *resultobj;
6074     wxIconBundle *arg1 = (wxIconBundle *) 0 ;
6075     PyObject * obj0 = 0 ;
6076     char *kwnames[] = {
6077         (char *) "self", NULL
6078     };
6079
6080     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconBundle",kwnames,&obj0)) goto fail;
6081     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
6082     if (SWIG_arg_fail(1)) SWIG_fail;
6083     {
6084         PyThreadState* __tstate = wxPyBeginAllowThreads();
6085         delete arg1;
6086
6087         wxPyEndAllowThreads(__tstate);
6088         if (PyErr_Occurred()) SWIG_fail;
6089     }
6090     Py_INCREF(Py_None); resultobj = Py_None;
6091     return resultobj;
6092     fail:
6093     return NULL;
6094 }
6095
6096
6097 static PyObject *_wrap_IconBundle_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
6098     PyObject *resultobj;
6099     wxIconBundle *arg1 = (wxIconBundle *) 0 ;
6100     wxIcon *arg2 = 0 ;
6101     PyObject * obj0 = 0 ;
6102     PyObject * obj1 = 0 ;
6103     char *kwnames[] = {
6104         (char *) "self",(char *) "icon", NULL
6105     };
6106
6107     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_AddIcon",kwnames,&obj0,&obj1)) goto fail;
6108     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
6109     if (SWIG_arg_fail(1)) SWIG_fail;
6110     {
6111         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
6112         if (SWIG_arg_fail(2)) SWIG_fail;
6113         if (arg2 == NULL) {
6114             SWIG_null_ref("wxIcon");
6115         }
6116         if (SWIG_arg_fail(2)) SWIG_fail;
6117     }
6118     {
6119         PyThreadState* __tstate = wxPyBeginAllowThreads();
6120         (arg1)->AddIcon((wxIcon const &)*arg2);
6121
6122         wxPyEndAllowThreads(__tstate);
6123         if (PyErr_Occurred()) SWIG_fail;
6124     }
6125     Py_INCREF(Py_None); resultobj = Py_None;
6126     return resultobj;
6127     fail:
6128     return NULL;
6129 }
6130
6131
6132 static PyObject *_wrap_IconBundle_AddIconFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
6133     PyObject *resultobj;
6134     wxIconBundle *arg1 = (wxIconBundle *) 0 ;
6135     wxString *arg2 = 0 ;
6136     long arg3 ;
6137     bool temp2 = false ;
6138     PyObject * obj0 = 0 ;
6139     PyObject * obj1 = 0 ;
6140     PyObject * obj2 = 0 ;
6141     char *kwnames[] = {
6142         (char *) "self",(char *) "file",(char *) "type", NULL
6143     };
6144
6145     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IconBundle_AddIconFromFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
6146     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
6147     if (SWIG_arg_fail(1)) SWIG_fail;
6148     {
6149         arg2 = wxString_in_helper(obj1);
6150         if (arg2 == NULL) SWIG_fail;
6151         temp2 = true;
6152     }
6153     {
6154         arg3 = (long)(SWIG_As_long(obj2));
6155         if (SWIG_arg_fail(3)) SWIG_fail;
6156     }
6157     {
6158         PyThreadState* __tstate = wxPyBeginAllowThreads();
6159         (arg1)->AddIcon((wxString const &)*arg2,arg3);
6160
6161         wxPyEndAllowThreads(__tstate);
6162         if (PyErr_Occurred()) SWIG_fail;
6163     }
6164     Py_INCREF(Py_None); resultobj = Py_None;
6165     {
6166         if (temp2)
6167         delete arg2;
6168     }
6169     return resultobj;
6170     fail:
6171     {
6172         if (temp2)
6173         delete arg2;
6174     }
6175     return NULL;
6176 }
6177
6178
6179 static PyObject *_wrap_IconBundle_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
6180     PyObject *resultobj;
6181     wxIconBundle *arg1 = (wxIconBundle *) 0 ;
6182     wxSize *arg2 = 0 ;
6183     wxIcon *result;
6184     wxSize temp2 ;
6185     PyObject * obj0 = 0 ;
6186     PyObject * obj1 = 0 ;
6187     char *kwnames[] = {
6188         (char *) "self",(char *) "size", NULL
6189     };
6190
6191     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_GetIcon",kwnames,&obj0,&obj1)) goto fail;
6192     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
6193     if (SWIG_arg_fail(1)) SWIG_fail;
6194     {
6195         arg2 = &temp2;
6196         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6197     }
6198     {
6199         PyThreadState* __tstate = wxPyBeginAllowThreads();
6200         {
6201             wxIcon const &_result_ref = ((wxIconBundle const *)arg1)->GetIcon((wxSize const &)*arg2);
6202             result = (wxIcon *) &_result_ref;
6203         }
6204
6205         wxPyEndAllowThreads(__tstate);
6206         if (PyErr_Occurred()) SWIG_fail;
6207     }
6208     {
6209         wxIcon* resultptr = new wxIcon(*result);
6210         resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxIcon, 1);
6211     }
6212     return resultobj;
6213     fail:
6214     return NULL;
6215 }
6216
6217
6218 static PyObject * IconBundle_swigregister(PyObject *, PyObject *args) {
6219     PyObject *obj;
6220     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6221     SWIG_TypeClientData(SWIGTYPE_p_wxIconBundle, obj);
6222     Py_INCREF(obj);
6223     return Py_BuildValue((char *)"");
6224 }
6225 static PyObject *_wrap_new_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
6226     PyObject *resultobj;
6227     wxString *arg1 = 0 ;
6228     long arg2 ;
6229     int arg3 = (int) 0 ;
6230     int arg4 = (int) 0 ;
6231     wxCursor *result;
6232     bool temp1 = false ;
6233     PyObject * obj0 = 0 ;
6234     PyObject * obj1 = 0 ;
6235     PyObject * obj2 = 0 ;
6236     PyObject * obj3 = 0 ;
6237     char *kwnames[] = {
6238         (char *) "cursorName",(char *) "type",(char *) "hotSpotX",(char *) "hotSpotY", NULL
6239     };
6240
6241     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Cursor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6242     {
6243         arg1 = wxString_in_helper(obj0);
6244         if (arg1 == NULL) SWIG_fail;
6245         temp1 = true;
6246     }
6247     {
6248         arg2 = (long)(SWIG_As_long(obj1));
6249         if (SWIG_arg_fail(2)) SWIG_fail;
6250     }
6251     if (obj2) {
6252         {
6253             arg3 = (int)(SWIG_As_int(obj2));
6254             if (SWIG_arg_fail(3)) SWIG_fail;
6255         }
6256     }
6257     if (obj3) {
6258         {
6259             arg4 = (int)(SWIG_As_int(obj3));
6260             if (SWIG_arg_fail(4)) SWIG_fail;
6261         }
6262     }
6263     {
6264         if (!wxPyCheckForApp()) SWIG_fail;
6265         PyThreadState* __tstate = wxPyBeginAllowThreads();
6266         result = (wxCursor *)new_wxCursor((wxString const &)*arg1,arg2,arg3,arg4);
6267
6268         wxPyEndAllowThreads(__tstate);
6269         if (PyErr_Occurred()) SWIG_fail;
6270     }
6271     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6272     {
6273         if (temp1)
6274         delete arg1;
6275     }
6276     return resultobj;
6277     fail:
6278     {
6279         if (temp1)
6280         delete arg1;
6281     }
6282     return NULL;
6283 }
6284
6285
6286 static PyObject *_wrap_delete_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
6287     PyObject *resultobj;
6288     wxCursor *arg1 = (wxCursor *) 0 ;
6289     PyObject * obj0 = 0 ;
6290     char *kwnames[] = {
6291         (char *) "self", NULL
6292     };
6293
6294     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Cursor",kwnames,&obj0)) goto fail;
6295     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6296     if (SWIG_arg_fail(1)) SWIG_fail;
6297     {
6298         PyThreadState* __tstate = wxPyBeginAllowThreads();
6299         delete arg1;
6300
6301         wxPyEndAllowThreads(__tstate);
6302         if (PyErr_Occurred()) SWIG_fail;
6303     }
6304     Py_INCREF(Py_None); resultobj = Py_None;
6305     return resultobj;
6306     fail:
6307     return NULL;
6308 }
6309
6310
6311 static PyObject *_wrap_new_StockCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6312     PyObject *resultobj;
6313     int arg1 ;
6314     wxCursor *result;
6315     PyObject * obj0 = 0 ;
6316     char *kwnames[] = {
6317         (char *) "id", NULL
6318     };
6319
6320     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_StockCursor",kwnames,&obj0)) goto fail;
6321     {
6322         arg1 = (int)(SWIG_As_int(obj0));
6323         if (SWIG_arg_fail(1)) SWIG_fail;
6324     }
6325     {
6326         if (!wxPyCheckForApp()) SWIG_fail;
6327         PyThreadState* __tstate = wxPyBeginAllowThreads();
6328         result = (wxCursor *)new wxCursor(arg1);
6329
6330         wxPyEndAllowThreads(__tstate);
6331         if (PyErr_Occurred()) SWIG_fail;
6332     }
6333     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6334     return resultobj;
6335     fail:
6336     return NULL;
6337 }
6338
6339
6340 static PyObject *_wrap_new_CursorFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
6341     PyObject *resultobj;
6342     wxImage *arg1 = 0 ;
6343     wxCursor *result;
6344     PyObject * obj0 = 0 ;
6345     char *kwnames[] = {
6346         (char *) "image", NULL
6347     };
6348
6349     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CursorFromImage",kwnames,&obj0)) goto fail;
6350     {
6351         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
6352         if (SWIG_arg_fail(1)) SWIG_fail;
6353         if (arg1 == NULL) {
6354             SWIG_null_ref("wxImage");
6355         }
6356         if (SWIG_arg_fail(1)) SWIG_fail;
6357     }
6358     {
6359         if (!wxPyCheckForApp()) SWIG_fail;
6360         PyThreadState* __tstate = wxPyBeginAllowThreads();
6361         result = (wxCursor *)new wxCursor((wxImage const &)*arg1);
6362
6363         wxPyEndAllowThreads(__tstate);
6364         if (PyErr_Occurred()) SWIG_fail;
6365     }
6366     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6367     return resultobj;
6368     fail:
6369     return NULL;
6370 }
6371
6372
6373 static PyObject *_wrap_Cursor_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
6374     PyObject *resultobj;
6375     wxCursor *arg1 = (wxCursor *) 0 ;
6376     long result;
6377     PyObject * obj0 = 0 ;
6378     char *kwnames[] = {
6379         (char *) "self", NULL
6380     };
6381
6382     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_GetHandle",kwnames,&obj0)) goto fail;
6383     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6384     if (SWIG_arg_fail(1)) SWIG_fail;
6385     {
6386         PyThreadState* __tstate = wxPyBeginAllowThreads();
6387         result = (long)(arg1)->GetHandle();
6388
6389         wxPyEndAllowThreads(__tstate);
6390         if (PyErr_Occurred()) SWIG_fail;
6391     }
6392     {
6393         resultobj = SWIG_From_long((long)(result));
6394     }
6395     return resultobj;
6396     fail:
6397     return NULL;
6398 }
6399
6400
6401 static PyObject *_wrap_Cursor_SetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
6402     PyObject *resultobj;
6403     wxCursor *arg1 = (wxCursor *) 0 ;
6404     long arg2 ;
6405     PyObject * obj0 = 0 ;
6406     PyObject * obj1 = 0 ;
6407     char *kwnames[] = {
6408         (char *) "self",(char *) "handle", NULL
6409     };
6410
6411     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetHandle",kwnames,&obj0,&obj1)) goto fail;
6412     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6413     if (SWIG_arg_fail(1)) SWIG_fail;
6414     {
6415         arg2 = (long)(SWIG_As_long(obj1));
6416         if (SWIG_arg_fail(2)) SWIG_fail;
6417     }
6418     {
6419         PyThreadState* __tstate = wxPyBeginAllowThreads();
6420         wxCursor_SetHandle(arg1,arg2);
6421
6422         wxPyEndAllowThreads(__tstate);
6423         if (PyErr_Occurred()) SWIG_fail;
6424     }
6425     Py_INCREF(Py_None); resultobj = Py_None;
6426     return resultobj;
6427     fail:
6428     return NULL;
6429 }
6430
6431
6432 static PyObject *_wrap_Cursor_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
6433     PyObject *resultobj;
6434     wxCursor *arg1 = (wxCursor *) 0 ;
6435     bool result;
6436     PyObject * obj0 = 0 ;
6437     char *kwnames[] = {
6438         (char *) "self", NULL
6439     };
6440
6441     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_Ok",kwnames,&obj0)) goto fail;
6442     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6443     if (SWIG_arg_fail(1)) SWIG_fail;
6444     {
6445         PyThreadState* __tstate = wxPyBeginAllowThreads();
6446         result = (bool)(arg1)->Ok();
6447
6448         wxPyEndAllowThreads(__tstate);
6449         if (PyErr_Occurred()) SWIG_fail;
6450     }
6451     {
6452         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6453     }
6454     return resultobj;
6455     fail:
6456     return NULL;
6457 }
6458
6459
6460 static PyObject *_wrap_Cursor_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
6461     PyObject *resultobj;
6462     wxCursor *arg1 = (wxCursor *) 0 ;
6463     int result;
6464     PyObject * obj0 = 0 ;
6465     char *kwnames[] = {
6466         (char *) "self", NULL
6467     };
6468
6469     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_GetWidth",kwnames,&obj0)) goto fail;
6470     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6471     if (SWIG_arg_fail(1)) SWIG_fail;
6472     {
6473         PyThreadState* __tstate = wxPyBeginAllowThreads();
6474         result = (int)(arg1)->GetWidth();
6475
6476         wxPyEndAllowThreads(__tstate);
6477         if (PyErr_Occurred()) SWIG_fail;
6478     }
6479     {
6480         resultobj = SWIG_From_int((int)(result));
6481     }
6482     return resultobj;
6483     fail:
6484     return NULL;
6485 }
6486
6487
6488 static PyObject *_wrap_Cursor_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
6489     PyObject *resultobj;
6490     wxCursor *arg1 = (wxCursor *) 0 ;
6491     int result;
6492     PyObject * obj0 = 0 ;
6493     char *kwnames[] = {
6494         (char *) "self", NULL
6495     };
6496
6497     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_GetHeight",kwnames,&obj0)) goto fail;
6498     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6499     if (SWIG_arg_fail(1)) SWIG_fail;
6500     {
6501         PyThreadState* __tstate = wxPyBeginAllowThreads();
6502         result = (int)(arg1)->GetHeight();
6503
6504         wxPyEndAllowThreads(__tstate);
6505         if (PyErr_Occurred()) SWIG_fail;
6506     }
6507     {
6508         resultobj = SWIG_From_int((int)(result));
6509     }
6510     return resultobj;
6511     fail:
6512     return NULL;
6513 }
6514
6515
6516 static PyObject *_wrap_Cursor_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
6517     PyObject *resultobj;
6518     wxCursor *arg1 = (wxCursor *) 0 ;
6519     int result;
6520     PyObject * obj0 = 0 ;
6521     char *kwnames[] = {
6522         (char *) "self", NULL
6523     };
6524
6525     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_GetDepth",kwnames,&obj0)) goto fail;
6526     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6527     if (SWIG_arg_fail(1)) SWIG_fail;
6528     {
6529         PyThreadState* __tstate = wxPyBeginAllowThreads();
6530         result = (int)(arg1)->GetDepth();
6531
6532         wxPyEndAllowThreads(__tstate);
6533         if (PyErr_Occurred()) SWIG_fail;
6534     }
6535     {
6536         resultobj = SWIG_From_int((int)(result));
6537     }
6538     return resultobj;
6539     fail:
6540     return NULL;
6541 }
6542
6543
6544 static PyObject *_wrap_Cursor_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
6545     PyObject *resultobj;
6546     wxCursor *arg1 = (wxCursor *) 0 ;
6547     int arg2 ;
6548     PyObject * obj0 = 0 ;
6549     PyObject * obj1 = 0 ;
6550     char *kwnames[] = {
6551         (char *) "self",(char *) "w", NULL
6552     };
6553
6554     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetWidth",kwnames,&obj0,&obj1)) goto fail;
6555     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6556     if (SWIG_arg_fail(1)) SWIG_fail;
6557     {
6558         arg2 = (int)(SWIG_As_int(obj1));
6559         if (SWIG_arg_fail(2)) SWIG_fail;
6560     }
6561     {
6562         PyThreadState* __tstate = wxPyBeginAllowThreads();
6563         (arg1)->SetWidth(arg2);
6564
6565         wxPyEndAllowThreads(__tstate);
6566         if (PyErr_Occurred()) SWIG_fail;
6567     }
6568     Py_INCREF(Py_None); resultobj = Py_None;
6569     return resultobj;
6570     fail:
6571     return NULL;
6572 }
6573
6574
6575 static PyObject *_wrap_Cursor_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
6576     PyObject *resultobj;
6577     wxCursor *arg1 = (wxCursor *) 0 ;
6578     int arg2 ;
6579     PyObject * obj0 = 0 ;
6580     PyObject * obj1 = 0 ;
6581     char *kwnames[] = {
6582         (char *) "self",(char *) "h", NULL
6583     };
6584
6585     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetHeight",kwnames,&obj0,&obj1)) goto fail;
6586     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6587     if (SWIG_arg_fail(1)) SWIG_fail;
6588     {
6589         arg2 = (int)(SWIG_As_int(obj1));
6590         if (SWIG_arg_fail(2)) SWIG_fail;
6591     }
6592     {
6593         PyThreadState* __tstate = wxPyBeginAllowThreads();
6594         (arg1)->SetHeight(arg2);
6595
6596         wxPyEndAllowThreads(__tstate);
6597         if (PyErr_Occurred()) SWIG_fail;
6598     }
6599     Py_INCREF(Py_None); resultobj = Py_None;
6600     return resultobj;
6601     fail:
6602     return NULL;
6603 }
6604
6605
6606 static PyObject *_wrap_Cursor_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
6607     PyObject *resultobj;
6608     wxCursor *arg1 = (wxCursor *) 0 ;
6609     int arg2 ;
6610     PyObject * obj0 = 0 ;
6611     PyObject * obj1 = 0 ;
6612     char *kwnames[] = {
6613         (char *) "self",(char *) "d", NULL
6614     };
6615
6616     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetDepth",kwnames,&obj0,&obj1)) goto fail;
6617     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6618     if (SWIG_arg_fail(1)) SWIG_fail;
6619     {
6620         arg2 = (int)(SWIG_As_int(obj1));
6621         if (SWIG_arg_fail(2)) SWIG_fail;
6622     }
6623     {
6624         PyThreadState* __tstate = wxPyBeginAllowThreads();
6625         (arg1)->SetDepth(arg2);
6626
6627         wxPyEndAllowThreads(__tstate);
6628         if (PyErr_Occurred()) SWIG_fail;
6629     }
6630     Py_INCREF(Py_None); resultobj = Py_None;
6631     return resultobj;
6632     fail:
6633     return NULL;
6634 }
6635
6636
6637 static PyObject *_wrap_Cursor_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6638     PyObject *resultobj;
6639     wxCursor *arg1 = (wxCursor *) 0 ;
6640     wxSize *arg2 = 0 ;
6641     wxSize temp2 ;
6642     PyObject * obj0 = 0 ;
6643     PyObject * obj1 = 0 ;
6644     char *kwnames[] = {
6645         (char *) "self",(char *) "size", NULL
6646     };
6647
6648     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetSize",kwnames,&obj0,&obj1)) goto fail;
6649     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6650     if (SWIG_arg_fail(1)) SWIG_fail;
6651     {
6652         arg2 = &temp2;
6653         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6654     }
6655     {
6656         PyThreadState* __tstate = wxPyBeginAllowThreads();
6657         (arg1)->SetSize((wxSize const &)*arg2);
6658
6659         wxPyEndAllowThreads(__tstate);
6660         if (PyErr_Occurred()) SWIG_fail;
6661     }
6662     Py_INCREF(Py_None); resultobj = Py_None;
6663     return resultobj;
6664     fail:
6665     return NULL;
6666 }
6667
6668
6669 static PyObject * Cursor_swigregister(PyObject *, PyObject *args) {
6670     PyObject *obj;
6671     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6672     SWIG_TypeClientData(SWIGTYPE_p_wxCursor, obj);
6673     Py_INCREF(obj);
6674     return Py_BuildValue((char *)"");
6675 }
6676 static PyObject *_wrap_new_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6677     PyObject *resultobj;
6678     int arg1 = (int) 0 ;
6679     int arg2 = (int) 0 ;
6680     int arg3 = (int) 0 ;
6681     int arg4 = (int) 0 ;
6682     wxRegion *result;
6683     PyObject * obj0 = 0 ;
6684     PyObject * obj1 = 0 ;
6685     PyObject * obj2 = 0 ;
6686     PyObject * obj3 = 0 ;
6687     char *kwnames[] = {
6688         (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6689     };
6690
6691     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Region",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6692     if (obj0) {
6693         {
6694             arg1 = (int)(SWIG_As_int(obj0));
6695             if (SWIG_arg_fail(1)) SWIG_fail;
6696         }
6697     }
6698     if (obj1) {
6699         {
6700             arg2 = (int)(SWIG_As_int(obj1));
6701             if (SWIG_arg_fail(2)) SWIG_fail;
6702         }
6703     }
6704     if (obj2) {
6705         {
6706             arg3 = (int)(SWIG_As_int(obj2));
6707             if (SWIG_arg_fail(3)) SWIG_fail;
6708         }
6709     }
6710     if (obj3) {
6711         {
6712             arg4 = (int)(SWIG_As_int(obj3));
6713             if (SWIG_arg_fail(4)) SWIG_fail;
6714         }
6715     }
6716     {
6717         if (!wxPyCheckForApp()) SWIG_fail;
6718         PyThreadState* __tstate = wxPyBeginAllowThreads();
6719         result = (wxRegion *)new wxRegion(arg1,arg2,arg3,arg4);
6720
6721         wxPyEndAllowThreads(__tstate);
6722         if (PyErr_Occurred()) SWIG_fail;
6723     }
6724     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6725     return resultobj;
6726     fail:
6727     return NULL;
6728 }
6729
6730
6731 static PyObject *_wrap_new_RegionFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6732     PyObject *resultobj;
6733     wxBitmap *arg1 = 0 ;
6734     wxRegion *result;
6735     PyObject * obj0 = 0 ;
6736     char *kwnames[] = {
6737         (char *) "bmp", NULL
6738     };
6739
6740     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionFromBitmap",kwnames,&obj0)) goto fail;
6741     {
6742         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6743         if (SWIG_arg_fail(1)) SWIG_fail;
6744         if (arg1 == NULL) {
6745             SWIG_null_ref("wxBitmap");
6746         }
6747         if (SWIG_arg_fail(1)) SWIG_fail;
6748     }
6749     {
6750         if (!wxPyCheckForApp()) SWIG_fail;
6751         PyThreadState* __tstate = wxPyBeginAllowThreads();
6752         result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1);
6753
6754         wxPyEndAllowThreads(__tstate);
6755         if (PyErr_Occurred()) SWIG_fail;
6756     }
6757     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6758     return resultobj;
6759     fail:
6760     return NULL;
6761 }
6762
6763
6764 static PyObject *_wrap_new_RegionFromBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
6765     PyObject *resultobj;
6766     wxBitmap *arg1 = 0 ;
6767     wxColour *arg2 = 0 ;
6768     int arg3 = (int) 0 ;
6769     wxRegion *result;
6770     wxColour temp2 ;
6771     PyObject * obj0 = 0 ;
6772     PyObject * obj1 = 0 ;
6773     PyObject * obj2 = 0 ;
6774     char *kwnames[] = {
6775         (char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
6776     };
6777
6778     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_RegionFromBitmapColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
6779     {
6780         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6781         if (SWIG_arg_fail(1)) SWIG_fail;
6782         if (arg1 == NULL) {
6783             SWIG_null_ref("wxBitmap");
6784         }
6785         if (SWIG_arg_fail(1)) SWIG_fail;
6786     }
6787     {
6788         arg2 = &temp2;
6789         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6790     }
6791     if (obj2) {
6792         {
6793             arg3 = (int)(SWIG_As_int(obj2));
6794             if (SWIG_arg_fail(3)) SWIG_fail;
6795         }
6796     }
6797     {
6798         if (!wxPyCheckForApp()) SWIG_fail;
6799         PyThreadState* __tstate = wxPyBeginAllowThreads();
6800         result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1,(wxColour const &)*arg2,arg3);
6801
6802         wxPyEndAllowThreads(__tstate);
6803         if (PyErr_Occurred()) SWIG_fail;
6804     }
6805     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6806     return resultobj;
6807     fail:
6808     return NULL;
6809 }
6810
6811
6812 static PyObject *_wrap_new_RegionFromPoints(PyObject *, PyObject *args, PyObject *kwargs) {
6813     PyObject *resultobj;
6814     int arg1 ;
6815     wxPoint *arg2 = (wxPoint *) 0 ;
6816     int arg3 = (int) wxWINDING_RULE ;
6817     wxRegion *result;
6818     PyObject * obj0 = 0 ;
6819     PyObject * obj1 = 0 ;
6820     char *kwnames[] = {
6821         (char *) "points",(char *) "fillStyle", NULL
6822     };
6823
6824     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_RegionFromPoints",kwnames,&obj0,&obj1)) goto fail;
6825     {
6826         arg2 = wxPoint_LIST_helper(obj0, &arg1);
6827         if (arg2 == NULL) SWIG_fail;
6828     }
6829     if (obj1) {
6830         {
6831             arg3 = (int)(SWIG_As_int(obj1));
6832             if (SWIG_arg_fail(3)) SWIG_fail;
6833         }
6834     }
6835     {
6836         if (!wxPyCheckForApp()) SWIG_fail;
6837         PyThreadState* __tstate = wxPyBeginAllowThreads();
6838         result = (wxRegion *)new wxRegion(arg1,arg2,arg3);
6839
6840         wxPyEndAllowThreads(__tstate);
6841         if (PyErr_Occurred()) SWIG_fail;
6842     }
6843     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6844     {
6845         if (arg2) delete [] arg2;
6846     }
6847     return resultobj;
6848     fail:
6849     {
6850         if (arg2) delete [] arg2;
6851     }
6852     return NULL;
6853 }
6854
6855
6856 static PyObject *_wrap_delete_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6857     PyObject *resultobj;
6858     wxRegion *arg1 = (wxRegion *) 0 ;
6859     PyObject * obj0 = 0 ;
6860     char *kwnames[] = {
6861         (char *) "self", NULL
6862     };
6863
6864     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Region",kwnames,&obj0)) goto fail;
6865     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6866     if (SWIG_arg_fail(1)) SWIG_fail;
6867     {
6868         PyThreadState* __tstate = wxPyBeginAllowThreads();
6869         delete arg1;
6870
6871         wxPyEndAllowThreads(__tstate);
6872         if (PyErr_Occurred()) SWIG_fail;
6873     }
6874     Py_INCREF(Py_None); resultobj = Py_None;
6875     return resultobj;
6876     fail:
6877     return NULL;
6878 }
6879
6880
6881 static PyObject *_wrap_Region_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
6882     PyObject *resultobj;
6883     wxRegion *arg1 = (wxRegion *) 0 ;
6884     PyObject * obj0 = 0 ;
6885     char *kwnames[] = {
6886         (char *) "self", NULL
6887     };
6888
6889     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_Clear",kwnames,&obj0)) goto fail;
6890     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6891     if (SWIG_arg_fail(1)) SWIG_fail;
6892     {
6893         PyThreadState* __tstate = wxPyBeginAllowThreads();
6894         (arg1)->Clear();
6895
6896         wxPyEndAllowThreads(__tstate);
6897         if (PyErr_Occurred()) SWIG_fail;
6898     }
6899     Py_INCREF(Py_None); resultobj = Py_None;
6900     return resultobj;
6901     fail:
6902     return NULL;
6903 }
6904
6905
6906 static PyObject *_wrap_Region_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
6907     PyObject *resultobj;
6908     wxRegion *arg1 = (wxRegion *) 0 ;
6909     int arg2 ;
6910     int arg3 ;
6911     bool result;
6912     PyObject * obj0 = 0 ;
6913     PyObject * obj1 = 0 ;
6914     PyObject * obj2 = 0 ;
6915     char *kwnames[] = {
6916         (char *) "self",(char *) "x",(char *) "y", NULL
6917     };
6918
6919     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Offset",kwnames,&obj0,&obj1,&obj2)) goto fail;
6920     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6921     if (SWIG_arg_fail(1)) SWIG_fail;
6922     {
6923         arg2 = (int)(SWIG_As_int(obj1));
6924         if (SWIG_arg_fail(2)) SWIG_fail;
6925     }
6926     {
6927         arg3 = (int)(SWIG_As_int(obj2));
6928         if (SWIG_arg_fail(3)) SWIG_fail;
6929     }
6930     {
6931         PyThreadState* __tstate = wxPyBeginAllowThreads();
6932         result = (bool)(arg1)->Offset(arg2,arg3);
6933
6934         wxPyEndAllowThreads(__tstate);
6935         if (PyErr_Occurred()) SWIG_fail;
6936     }
6937     {
6938         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6939     }
6940     return resultobj;
6941     fail:
6942     return NULL;
6943 }
6944
6945
6946 static PyObject *_wrap_Region_Contains(PyObject *, PyObject *args, PyObject *kwargs) {
6947     PyObject *resultobj;
6948     wxRegion *arg1 = (wxRegion *) 0 ;
6949     int arg2 ;
6950     int arg3 ;
6951     wxRegionContain result;
6952     PyObject * obj0 = 0 ;
6953     PyObject * obj1 = 0 ;
6954     PyObject * obj2 = 0 ;
6955     char *kwnames[] = {
6956         (char *) "self",(char *) "x",(char *) "y", NULL
6957     };
6958
6959     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Contains",kwnames,&obj0,&obj1,&obj2)) goto fail;
6960     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6961     if (SWIG_arg_fail(1)) SWIG_fail;
6962     {
6963         arg2 = (int)(SWIG_As_int(obj1));
6964         if (SWIG_arg_fail(2)) SWIG_fail;
6965     }
6966     {
6967         arg3 = (int)(SWIG_As_int(obj2));
6968         if (SWIG_arg_fail(3)) SWIG_fail;
6969     }
6970     {
6971         PyThreadState* __tstate = wxPyBeginAllowThreads();
6972         result = (wxRegionContain)(arg1)->Contains(arg2,arg3);
6973
6974         wxPyEndAllowThreads(__tstate);
6975         if (PyErr_Occurred()) SWIG_fail;
6976     }
6977     resultobj = SWIG_From_int((result));
6978     return resultobj;
6979     fail:
6980     return NULL;
6981 }
6982
6983
6984 static PyObject *_wrap_Region_ContainsPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6985     PyObject *resultobj;
6986     wxRegion *arg1 = (wxRegion *) 0 ;
6987     wxPoint *arg2 = 0 ;
6988     wxRegionContain result;
6989     wxPoint temp2 ;
6990     PyObject * obj0 = 0 ;
6991     PyObject * obj1 = 0 ;
6992     char *kwnames[] = {
6993         (char *) "self",(char *) "pt", NULL
6994     };
6995
6996     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsPoint",kwnames,&obj0,&obj1)) goto fail;
6997     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6998     if (SWIG_arg_fail(1)) SWIG_fail;
6999     {
7000         arg2 = &temp2;
7001         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7002     }
7003     {
7004         PyThreadState* __tstate = wxPyBeginAllowThreads();
7005         result = (wxRegionContain)(arg1)->Contains((wxPoint const &)*arg2);
7006
7007         wxPyEndAllowThreads(__tstate);
7008         if (PyErr_Occurred()) SWIG_fail;
7009     }
7010     resultobj = SWIG_From_int((result));
7011     return resultobj;
7012     fail:
7013     return NULL;
7014 }
7015
7016
7017 static PyObject *_wrap_Region_ContainsRect(PyObject *, PyObject *args, PyObject *kwargs) {
7018     PyObject *resultobj;
7019     wxRegion *arg1 = (wxRegion *) 0 ;
7020     wxRect *arg2 = 0 ;
7021     wxRegionContain result;
7022     wxRect temp2 ;
7023     PyObject * obj0 = 0 ;
7024     PyObject * obj1 = 0 ;
7025     char *kwnames[] = {
7026         (char *) "self",(char *) "rect", NULL
7027     };
7028
7029     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsRect",kwnames,&obj0,&obj1)) goto fail;
7030     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7031     if (SWIG_arg_fail(1)) SWIG_fail;
7032     {
7033         arg2 = &temp2;
7034         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7035     }
7036     {
7037         PyThreadState* __tstate = wxPyBeginAllowThreads();
7038         result = (wxRegionContain)(arg1)->Contains((wxRect const &)*arg2);
7039
7040         wxPyEndAllowThreads(__tstate);
7041         if (PyErr_Occurred()) SWIG_fail;
7042     }
7043     resultobj = SWIG_From_int((result));
7044     return resultobj;
7045     fail:
7046     return NULL;
7047 }
7048
7049
7050 static PyObject *_wrap_Region_ContainsRectDim(PyObject *, PyObject *args, PyObject *kwargs) {
7051     PyObject *resultobj;
7052     wxRegion *arg1 = (wxRegion *) 0 ;
7053     int arg2 ;
7054     int arg3 ;
7055     int arg4 ;
7056     int arg5 ;
7057     wxRegionContain result;
7058     PyObject * obj0 = 0 ;
7059     PyObject * obj1 = 0 ;
7060     PyObject * obj2 = 0 ;
7061     PyObject * obj3 = 0 ;
7062     PyObject * obj4 = 0 ;
7063     char *kwnames[] = {
7064         (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
7065     };
7066
7067     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_ContainsRectDim",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7068     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7069     if (SWIG_arg_fail(1)) SWIG_fail;
7070     {
7071         arg2 = (int)(SWIG_As_int(obj1));
7072         if (SWIG_arg_fail(2)) SWIG_fail;
7073     }
7074     {
7075         arg3 = (int)(SWIG_As_int(obj2));
7076         if (SWIG_arg_fail(3)) SWIG_fail;
7077     }
7078     {
7079         arg4 = (int)(SWIG_As_int(obj3));
7080         if (SWIG_arg_fail(4)) SWIG_fail;
7081     }
7082     {
7083         arg5 = (int)(SWIG_As_int(obj4));
7084         if (SWIG_arg_fail(5)) SWIG_fail;
7085     }
7086     {
7087         PyThreadState* __tstate = wxPyBeginAllowThreads();
7088         result = (wxRegionContain)(arg1)->Contains(arg2,arg3,arg4,arg5);
7089
7090         wxPyEndAllowThreads(__tstate);
7091         if (PyErr_Occurred()) SWIG_fail;
7092     }
7093     resultobj = SWIG_From_int((result));
7094     return resultobj;
7095     fail:
7096     return NULL;
7097 }
7098
7099
7100 static PyObject *_wrap_Region_GetBox(PyObject *, PyObject *args, PyObject *kwargs) {
7101     PyObject *resultobj;
7102     wxRegion *arg1 = (wxRegion *) 0 ;
7103     wxRect result;
7104     PyObject * obj0 = 0 ;
7105     char *kwnames[] = {
7106         (char *) "self", NULL
7107     };
7108
7109     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_GetBox",kwnames,&obj0)) goto fail;
7110     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7111     if (SWIG_arg_fail(1)) SWIG_fail;
7112     {
7113         PyThreadState* __tstate = wxPyBeginAllowThreads();
7114         result = (arg1)->GetBox();
7115
7116         wxPyEndAllowThreads(__tstate);
7117         if (PyErr_Occurred()) SWIG_fail;
7118     }
7119     {
7120         wxRect * resultptr;
7121         resultptr = new wxRect((wxRect &)(result));
7122         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
7123     }
7124     return resultobj;
7125     fail:
7126     return NULL;
7127 }
7128
7129
7130 static PyObject *_wrap_Region_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
7131     PyObject *resultobj;
7132     wxRegion *arg1 = (wxRegion *) 0 ;
7133     int arg2 ;
7134     int arg3 ;
7135     int arg4 ;
7136     int arg5 ;
7137     bool result;
7138     PyObject * obj0 = 0 ;
7139     PyObject * obj1 = 0 ;
7140     PyObject * obj2 = 0 ;
7141     PyObject * obj3 = 0 ;
7142     PyObject * obj4 = 0 ;
7143     char *kwnames[] = {
7144         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7145     };
7146
7147     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Intersect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7148     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7149     if (SWIG_arg_fail(1)) SWIG_fail;
7150     {
7151         arg2 = (int)(SWIG_As_int(obj1));
7152         if (SWIG_arg_fail(2)) SWIG_fail;
7153     }
7154     {
7155         arg3 = (int)(SWIG_As_int(obj2));
7156         if (SWIG_arg_fail(3)) SWIG_fail;
7157     }
7158     {
7159         arg4 = (int)(SWIG_As_int(obj3));
7160         if (SWIG_arg_fail(4)) SWIG_fail;
7161     }
7162     {
7163         arg5 = (int)(SWIG_As_int(obj4));
7164         if (SWIG_arg_fail(5)) SWIG_fail;
7165     }
7166     {
7167         PyThreadState* __tstate = wxPyBeginAllowThreads();
7168         result = (bool)(arg1)->Intersect(arg2,arg3,arg4,arg5);
7169
7170         wxPyEndAllowThreads(__tstate);
7171         if (PyErr_Occurred()) SWIG_fail;
7172     }
7173     {
7174         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7175     }
7176     return resultobj;
7177     fail:
7178     return NULL;
7179 }
7180
7181
7182 static PyObject *_wrap_Region_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
7183     PyObject *resultobj;
7184     wxRegion *arg1 = (wxRegion *) 0 ;
7185     wxRect *arg2 = 0 ;
7186     bool result;
7187     wxRect temp2 ;
7188     PyObject * obj0 = 0 ;
7189     PyObject * obj1 = 0 ;
7190     char *kwnames[] = {
7191         (char *) "self",(char *) "rect", NULL
7192     };
7193
7194     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRect",kwnames,&obj0,&obj1)) goto fail;
7195     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7196     if (SWIG_arg_fail(1)) SWIG_fail;
7197     {
7198         arg2 = &temp2;
7199         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7200     }
7201     {
7202         PyThreadState* __tstate = wxPyBeginAllowThreads();
7203         result = (bool)(arg1)->Intersect((wxRect const &)*arg2);
7204
7205         wxPyEndAllowThreads(__tstate);
7206         if (PyErr_Occurred()) SWIG_fail;
7207     }
7208     {
7209         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7210     }
7211     return resultobj;
7212     fail:
7213     return NULL;
7214 }
7215
7216
7217 static PyObject *_wrap_Region_IntersectRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7218     PyObject *resultobj;
7219     wxRegion *arg1 = (wxRegion *) 0 ;
7220     wxRegion *arg2 = 0 ;
7221     bool result;
7222     PyObject * obj0 = 0 ;
7223     PyObject * obj1 = 0 ;
7224     char *kwnames[] = {
7225         (char *) "self",(char *) "region", NULL
7226     };
7227
7228     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRegion",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         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7233         if (SWIG_arg_fail(2)) SWIG_fail;
7234         if (arg2 == NULL) {
7235             SWIG_null_ref("wxRegion");
7236         }
7237         if (SWIG_arg_fail(2)) SWIG_fail;
7238     }
7239     {
7240         PyThreadState* __tstate = wxPyBeginAllowThreads();
7241         result = (bool)(arg1)->Intersect((wxRegion const &)*arg2);
7242
7243         wxPyEndAllowThreads(__tstate);
7244         if (PyErr_Occurred()) SWIG_fail;
7245     }
7246     {
7247         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7248     }
7249     return resultobj;
7250     fail:
7251     return NULL;
7252 }
7253
7254
7255 static PyObject *_wrap_Region_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
7256     PyObject *resultobj;
7257     wxRegion *arg1 = (wxRegion *) 0 ;
7258     bool result;
7259     PyObject * obj0 = 0 ;
7260     char *kwnames[] = {
7261         (char *) "self", NULL
7262     };
7263
7264     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_IsEmpty",kwnames,&obj0)) goto fail;
7265     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7266     if (SWIG_arg_fail(1)) SWIG_fail;
7267     {
7268         PyThreadState* __tstate = wxPyBeginAllowThreads();
7269         result = (bool)(arg1)->IsEmpty();
7270
7271         wxPyEndAllowThreads(__tstate);
7272         if (PyErr_Occurred()) SWIG_fail;
7273     }
7274     {
7275         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7276     }
7277     return resultobj;
7278     fail:
7279     return NULL;
7280 }
7281
7282
7283 static PyObject *_wrap_Region_Union(PyObject *, PyObject *args, PyObject *kwargs) {
7284     PyObject *resultobj;
7285     wxRegion *arg1 = (wxRegion *) 0 ;
7286     int arg2 ;
7287     int arg3 ;
7288     int arg4 ;
7289     int arg5 ;
7290     bool result;
7291     PyObject * obj0 = 0 ;
7292     PyObject * obj1 = 0 ;
7293     PyObject * obj2 = 0 ;
7294     PyObject * obj3 = 0 ;
7295     PyObject * obj4 = 0 ;
7296     char *kwnames[] = {
7297         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7298     };
7299
7300     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Union",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7301     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7302     if (SWIG_arg_fail(1)) SWIG_fail;
7303     {
7304         arg2 = (int)(SWIG_As_int(obj1));
7305         if (SWIG_arg_fail(2)) SWIG_fail;
7306     }
7307     {
7308         arg3 = (int)(SWIG_As_int(obj2));
7309         if (SWIG_arg_fail(3)) SWIG_fail;
7310     }
7311     {
7312         arg4 = (int)(SWIG_As_int(obj3));
7313         if (SWIG_arg_fail(4)) SWIG_fail;
7314     }
7315     {
7316         arg5 = (int)(SWIG_As_int(obj4));
7317         if (SWIG_arg_fail(5)) SWIG_fail;
7318     }
7319     {
7320         PyThreadState* __tstate = wxPyBeginAllowThreads();
7321         result = (bool)(arg1)->Union(arg2,arg3,arg4,arg5);
7322
7323         wxPyEndAllowThreads(__tstate);
7324         if (PyErr_Occurred()) SWIG_fail;
7325     }
7326     {
7327         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7328     }
7329     return resultobj;
7330     fail:
7331     return NULL;
7332 }
7333
7334
7335 static PyObject *_wrap_Region_UnionRect(PyObject *, PyObject *args, PyObject *kwargs) {
7336     PyObject *resultobj;
7337     wxRegion *arg1 = (wxRegion *) 0 ;
7338     wxRect *arg2 = 0 ;
7339     bool result;
7340     wxRect temp2 ;
7341     PyObject * obj0 = 0 ;
7342     PyObject * obj1 = 0 ;
7343     char *kwnames[] = {
7344         (char *) "self",(char *) "rect", NULL
7345     };
7346
7347     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRect",kwnames,&obj0,&obj1)) goto fail;
7348     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7349     if (SWIG_arg_fail(1)) SWIG_fail;
7350     {
7351         arg2 = &temp2;
7352         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7353     }
7354     {
7355         PyThreadState* __tstate = wxPyBeginAllowThreads();
7356         result = (bool)(arg1)->Union((wxRect const &)*arg2);
7357
7358         wxPyEndAllowThreads(__tstate);
7359         if (PyErr_Occurred()) SWIG_fail;
7360     }
7361     {
7362         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7363     }
7364     return resultobj;
7365     fail:
7366     return NULL;
7367 }
7368
7369
7370 static PyObject *_wrap_Region_UnionRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7371     PyObject *resultobj;
7372     wxRegion *arg1 = (wxRegion *) 0 ;
7373     wxRegion *arg2 = 0 ;
7374     bool result;
7375     PyObject * obj0 = 0 ;
7376     PyObject * obj1 = 0 ;
7377     char *kwnames[] = {
7378         (char *) "self",(char *) "region", NULL
7379     };
7380
7381     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRegion",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         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7386         if (SWIG_arg_fail(2)) SWIG_fail;
7387         if (arg2 == NULL) {
7388             SWIG_null_ref("wxRegion");
7389         }
7390         if (SWIG_arg_fail(2)) SWIG_fail;
7391     }
7392     {
7393         PyThreadState* __tstate = wxPyBeginAllowThreads();
7394         result = (bool)(arg1)->Union((wxRegion const &)*arg2);
7395
7396         wxPyEndAllowThreads(__tstate);
7397         if (PyErr_Occurred()) SWIG_fail;
7398     }
7399     {
7400         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7401     }
7402     return resultobj;
7403     fail:
7404     return NULL;
7405 }
7406
7407
7408 static PyObject *_wrap_Region_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
7409     PyObject *resultobj;
7410     wxRegion *arg1 = (wxRegion *) 0 ;
7411     int arg2 ;
7412     int arg3 ;
7413     int arg4 ;
7414     int arg5 ;
7415     bool result;
7416     PyObject * obj0 = 0 ;
7417     PyObject * obj1 = 0 ;
7418     PyObject * obj2 = 0 ;
7419     PyObject * obj3 = 0 ;
7420     PyObject * obj4 = 0 ;
7421     char *kwnames[] = {
7422         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7423     };
7424
7425     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Subtract",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7426     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7427     if (SWIG_arg_fail(1)) SWIG_fail;
7428     {
7429         arg2 = (int)(SWIG_As_int(obj1));
7430         if (SWIG_arg_fail(2)) SWIG_fail;
7431     }
7432     {
7433         arg3 = (int)(SWIG_As_int(obj2));
7434         if (SWIG_arg_fail(3)) SWIG_fail;
7435     }
7436     {
7437         arg4 = (int)(SWIG_As_int(obj3));
7438         if (SWIG_arg_fail(4)) SWIG_fail;
7439     }
7440     {
7441         arg5 = (int)(SWIG_As_int(obj4));
7442         if (SWIG_arg_fail(5)) SWIG_fail;
7443     }
7444     {
7445         PyThreadState* __tstate = wxPyBeginAllowThreads();
7446         result = (bool)(arg1)->Subtract(arg2,arg3,arg4,arg5);
7447
7448         wxPyEndAllowThreads(__tstate);
7449         if (PyErr_Occurred()) SWIG_fail;
7450     }
7451     {
7452         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7453     }
7454     return resultobj;
7455     fail:
7456     return NULL;
7457 }
7458
7459
7460 static PyObject *_wrap_Region_SubtractRect(PyObject *, PyObject *args, PyObject *kwargs) {
7461     PyObject *resultobj;
7462     wxRegion *arg1 = (wxRegion *) 0 ;
7463     wxRect *arg2 = 0 ;
7464     bool result;
7465     wxRect temp2 ;
7466     PyObject * obj0 = 0 ;
7467     PyObject * obj1 = 0 ;
7468     char *kwnames[] = {
7469         (char *) "self",(char *) "rect", NULL
7470     };
7471
7472     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRect",kwnames,&obj0,&obj1)) goto fail;
7473     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7474     if (SWIG_arg_fail(1)) SWIG_fail;
7475     {
7476         arg2 = &temp2;
7477         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7478     }
7479     {
7480         PyThreadState* __tstate = wxPyBeginAllowThreads();
7481         result = (bool)(arg1)->Subtract((wxRect const &)*arg2);
7482
7483         wxPyEndAllowThreads(__tstate);
7484         if (PyErr_Occurred()) SWIG_fail;
7485     }
7486     {
7487         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7488     }
7489     return resultobj;
7490     fail:
7491     return NULL;
7492 }
7493
7494
7495 static PyObject *_wrap_Region_SubtractRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7496     PyObject *resultobj;
7497     wxRegion *arg1 = (wxRegion *) 0 ;
7498     wxRegion *arg2 = 0 ;
7499     bool result;
7500     PyObject * obj0 = 0 ;
7501     PyObject * obj1 = 0 ;
7502     char *kwnames[] = {
7503         (char *) "self",(char *) "region", NULL
7504     };
7505
7506     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRegion",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         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7511         if (SWIG_arg_fail(2)) SWIG_fail;
7512         if (arg2 == NULL) {
7513             SWIG_null_ref("wxRegion");
7514         }
7515         if (SWIG_arg_fail(2)) SWIG_fail;
7516     }
7517     {
7518         PyThreadState* __tstate = wxPyBeginAllowThreads();
7519         result = (bool)(arg1)->Subtract((wxRegion const &)*arg2);
7520
7521         wxPyEndAllowThreads(__tstate);
7522         if (PyErr_Occurred()) SWIG_fail;
7523     }
7524     {
7525         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7526     }
7527     return resultobj;
7528     fail:
7529     return NULL;
7530 }
7531
7532
7533 static PyObject *_wrap_Region_Xor(PyObject *, PyObject *args, PyObject *kwargs) {
7534     PyObject *resultobj;
7535     wxRegion *arg1 = (wxRegion *) 0 ;
7536     int arg2 ;
7537     int arg3 ;
7538     int arg4 ;
7539     int arg5 ;
7540     bool result;
7541     PyObject * obj0 = 0 ;
7542     PyObject * obj1 = 0 ;
7543     PyObject * obj2 = 0 ;
7544     PyObject * obj3 = 0 ;
7545     PyObject * obj4 = 0 ;
7546     char *kwnames[] = {
7547         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7548     };
7549
7550     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Xor",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7551     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7552     if (SWIG_arg_fail(1)) SWIG_fail;
7553     {
7554         arg2 = (int)(SWIG_As_int(obj1));
7555         if (SWIG_arg_fail(2)) SWIG_fail;
7556     }
7557     {
7558         arg3 = (int)(SWIG_As_int(obj2));
7559         if (SWIG_arg_fail(3)) SWIG_fail;
7560     }
7561     {
7562         arg4 = (int)(SWIG_As_int(obj3));
7563         if (SWIG_arg_fail(4)) SWIG_fail;
7564     }
7565     {
7566         arg5 = (int)(SWIG_As_int(obj4));
7567         if (SWIG_arg_fail(5)) SWIG_fail;
7568     }
7569     {
7570         PyThreadState* __tstate = wxPyBeginAllowThreads();
7571         result = (bool)(arg1)->Xor(arg2,arg3,arg4,arg5);
7572
7573         wxPyEndAllowThreads(__tstate);
7574         if (PyErr_Occurred()) SWIG_fail;
7575     }
7576     {
7577         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7578     }
7579     return resultobj;
7580     fail:
7581     return NULL;
7582 }
7583
7584
7585 static PyObject *_wrap_Region_XorRect(PyObject *, PyObject *args, PyObject *kwargs) {
7586     PyObject *resultobj;
7587     wxRegion *arg1 = (wxRegion *) 0 ;
7588     wxRect *arg2 = 0 ;
7589     bool result;
7590     wxRect temp2 ;
7591     PyObject * obj0 = 0 ;
7592     PyObject * obj1 = 0 ;
7593     char *kwnames[] = {
7594         (char *) "self",(char *) "rect", NULL
7595     };
7596
7597     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRect",kwnames,&obj0,&obj1)) goto fail;
7598     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7599     if (SWIG_arg_fail(1)) SWIG_fail;
7600     {
7601         arg2 = &temp2;
7602         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7603     }
7604     {
7605         PyThreadState* __tstate = wxPyBeginAllowThreads();
7606         result = (bool)(arg1)->Xor((wxRect const &)*arg2);
7607
7608         wxPyEndAllowThreads(__tstate);
7609         if (PyErr_Occurred()) SWIG_fail;
7610     }
7611     {
7612         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7613     }
7614     return resultobj;
7615     fail:
7616     return NULL;
7617 }
7618
7619
7620 static PyObject *_wrap_Region_XorRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7621     PyObject *resultobj;
7622     wxRegion *arg1 = (wxRegion *) 0 ;
7623     wxRegion *arg2 = 0 ;
7624     bool result;
7625     PyObject * obj0 = 0 ;
7626     PyObject * obj1 = 0 ;
7627     char *kwnames[] = {
7628         (char *) "self",(char *) "region", NULL
7629     };
7630
7631     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRegion",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         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7636         if (SWIG_arg_fail(2)) SWIG_fail;
7637         if (arg2 == NULL) {
7638             SWIG_null_ref("wxRegion");
7639         }
7640         if (SWIG_arg_fail(2)) SWIG_fail;
7641     }
7642     {
7643         PyThreadState* __tstate = wxPyBeginAllowThreads();
7644         result = (bool)(arg1)->Xor((wxRegion const &)*arg2);
7645
7646         wxPyEndAllowThreads(__tstate);
7647         if (PyErr_Occurred()) SWIG_fail;
7648     }
7649     {
7650         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7651     }
7652     return resultobj;
7653     fail:
7654     return NULL;
7655 }
7656
7657
7658 static PyObject *_wrap_Region_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7659     PyObject *resultobj;
7660     wxRegion *arg1 = (wxRegion *) 0 ;
7661     SwigValueWrapper<wxBitmap > result;
7662     PyObject * obj0 = 0 ;
7663     char *kwnames[] = {
7664         (char *) "self", NULL
7665     };
7666
7667     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_ConvertToBitmap",kwnames,&obj0)) goto fail;
7668     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7669     if (SWIG_arg_fail(1)) SWIG_fail;
7670     {
7671         PyThreadState* __tstate = wxPyBeginAllowThreads();
7672         result = (arg1)->ConvertToBitmap();
7673
7674         wxPyEndAllowThreads(__tstate);
7675         if (PyErr_Occurred()) SWIG_fail;
7676     }
7677     {
7678         wxBitmap * resultptr;
7679         resultptr = new wxBitmap((wxBitmap &)(result));
7680         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
7681     }
7682     return resultobj;
7683     fail:
7684     return NULL;
7685 }
7686
7687
7688 static PyObject *_wrap_Region_UnionBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7689     PyObject *resultobj;
7690     wxRegion *arg1 = (wxRegion *) 0 ;
7691     wxBitmap *arg2 = 0 ;
7692     bool result;
7693     PyObject * obj0 = 0 ;
7694     PyObject * obj1 = 0 ;
7695     char *kwnames[] = {
7696         (char *) "self",(char *) "bmp", NULL
7697     };
7698
7699     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionBitmap",kwnames,&obj0,&obj1)) goto fail;
7700     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7701     if (SWIG_arg_fail(1)) SWIG_fail;
7702     {
7703         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7704         if (SWIG_arg_fail(2)) SWIG_fail;
7705         if (arg2 == NULL) {
7706             SWIG_null_ref("wxBitmap");
7707         }
7708         if (SWIG_arg_fail(2)) SWIG_fail;
7709     }
7710     {
7711         PyThreadState* __tstate = wxPyBeginAllowThreads();
7712         result = (bool)(arg1)->Union((wxBitmap const &)*arg2);
7713
7714         wxPyEndAllowThreads(__tstate);
7715         if (PyErr_Occurred()) SWIG_fail;
7716     }
7717     {
7718         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7719     }
7720     return resultobj;
7721     fail:
7722     return NULL;
7723 }
7724
7725
7726 static PyObject *_wrap_Region_UnionBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
7727     PyObject *resultobj;
7728     wxRegion *arg1 = (wxRegion *) 0 ;
7729     wxBitmap *arg2 = 0 ;
7730     wxColour *arg3 = 0 ;
7731     int arg4 = (int) 0 ;
7732     bool result;
7733     wxColour temp3 ;
7734     PyObject * obj0 = 0 ;
7735     PyObject * obj1 = 0 ;
7736     PyObject * obj2 = 0 ;
7737     PyObject * obj3 = 0 ;
7738     char *kwnames[] = {
7739         (char *) "self",(char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
7740     };
7741
7742     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Region_UnionBitmapColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7743     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7744     if (SWIG_arg_fail(1)) SWIG_fail;
7745     {
7746         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7747         if (SWIG_arg_fail(2)) SWIG_fail;
7748         if (arg2 == NULL) {
7749             SWIG_null_ref("wxBitmap");
7750         }
7751         if (SWIG_arg_fail(2)) SWIG_fail;
7752     }
7753     {
7754         arg3 = &temp3;
7755         if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
7756     }
7757     if (obj3) {
7758         {
7759             arg4 = (int)(SWIG_As_int(obj3));
7760             if (SWIG_arg_fail(4)) SWIG_fail;
7761         }
7762     }
7763     {
7764         PyThreadState* __tstate = wxPyBeginAllowThreads();
7765         result = (bool)(arg1)->Union((wxBitmap const &)*arg2,(wxColour const &)*arg3,arg4);
7766
7767         wxPyEndAllowThreads(__tstate);
7768         if (PyErr_Occurred()) SWIG_fail;
7769     }
7770     {
7771         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7772     }
7773     return resultobj;
7774     fail:
7775     return NULL;
7776 }
7777
7778
7779 static PyObject * Region_swigregister(PyObject *, PyObject *args) {
7780     PyObject *obj;
7781     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7782     SWIG_TypeClientData(SWIGTYPE_p_wxRegion, obj);
7783     Py_INCREF(obj);
7784     return Py_BuildValue((char *)"");
7785 }
7786 static PyObject *_wrap_new_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7787     PyObject *resultobj;
7788     wxRegion *arg1 = 0 ;
7789     wxRegionIterator *result;
7790     PyObject * obj0 = 0 ;
7791     char *kwnames[] = {
7792         (char *) "region", NULL
7793     };
7794
7795     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionIterator",kwnames,&obj0)) goto fail;
7796     {
7797         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7798         if (SWIG_arg_fail(1)) SWIG_fail;
7799         if (arg1 == NULL) {
7800             SWIG_null_ref("wxRegion");
7801         }
7802         if (SWIG_arg_fail(1)) SWIG_fail;
7803     }
7804     {
7805         if (!wxPyCheckForApp()) SWIG_fail;
7806         PyThreadState* __tstate = wxPyBeginAllowThreads();
7807         result = (wxRegionIterator *)new wxRegionIterator((wxRegion const &)*arg1);
7808
7809         wxPyEndAllowThreads(__tstate);
7810         if (PyErr_Occurred()) SWIG_fail;
7811     }
7812     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegionIterator, 1);
7813     return resultobj;
7814     fail:
7815     return NULL;
7816 }
7817
7818
7819 static PyObject *_wrap_delete_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7820     PyObject *resultobj;
7821     wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7822     PyObject * obj0 = 0 ;
7823     char *kwnames[] = {
7824         (char *) "self", NULL
7825     };
7826
7827     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RegionIterator",kwnames,&obj0)) goto fail;
7828     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7829     if (SWIG_arg_fail(1)) SWIG_fail;
7830     {
7831         PyThreadState* __tstate = wxPyBeginAllowThreads();
7832         delete arg1;
7833
7834         wxPyEndAllowThreads(__tstate);
7835         if (PyErr_Occurred()) SWIG_fail;
7836     }
7837     Py_INCREF(Py_None); resultobj = Py_None;
7838     return resultobj;
7839     fail:
7840     return NULL;
7841 }
7842
7843
7844 static PyObject *_wrap_RegionIterator_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
7845     PyObject *resultobj;
7846     wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7847     int result;
7848     PyObject * obj0 = 0 ;
7849     char *kwnames[] = {
7850         (char *) "self", NULL
7851     };
7852
7853     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetX",kwnames,&obj0)) goto fail;
7854     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7855     if (SWIG_arg_fail(1)) SWIG_fail;
7856     {
7857         PyThreadState* __tstate = wxPyBeginAllowThreads();
7858         result = (int)(arg1)->GetX();
7859
7860         wxPyEndAllowThreads(__tstate);
7861         if (PyErr_Occurred()) SWIG_fail;
7862     }
7863     {
7864         resultobj = SWIG_From_int((int)(result));
7865     }
7866     return resultobj;
7867     fail:
7868     return NULL;
7869 }
7870
7871
7872 static PyObject *_wrap_RegionIterator_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
7873     PyObject *resultobj;
7874     wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7875     int result;
7876     PyObject * obj0 = 0 ;
7877     char *kwnames[] = {
7878         (char *) "self", NULL
7879     };
7880
7881     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetY",kwnames,&obj0)) goto fail;
7882     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7883     if (SWIG_arg_fail(1)) SWIG_fail;
7884     {
7885         PyThreadState* __tstate = wxPyBeginAllowThreads();
7886         result = (int)(arg1)->GetY();
7887
7888         wxPyEndAllowThreads(__tstate);
7889         if (PyErr_Occurred()) SWIG_fail;
7890     }
7891     {
7892         resultobj = SWIG_From_int((int)(result));
7893     }
7894     return resultobj;
7895     fail:
7896     return NULL;
7897 }
7898
7899
7900 static PyObject *_wrap_RegionIterator_GetW(PyObject *, PyObject *args, PyObject *kwargs) {
7901     PyObject *resultobj;
7902     wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7903     int result;
7904     PyObject * obj0 = 0 ;
7905     char *kwnames[] = {
7906         (char *) "self", NULL
7907     };
7908
7909     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetW",kwnames,&obj0)) goto fail;
7910     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7911     if (SWIG_arg_fail(1)) SWIG_fail;
7912     {
7913         PyThreadState* __tstate = wxPyBeginAllowThreads();
7914         result = (int)(arg1)->GetW();
7915
7916         wxPyEndAllowThreads(__tstate);
7917         if (PyErr_Occurred()) SWIG_fail;
7918     }
7919     {
7920         resultobj = SWIG_From_int((int)(result));
7921     }
7922     return resultobj;
7923     fail:
7924     return NULL;
7925 }
7926
7927
7928 static PyObject *_wrap_RegionIterator_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
7929     PyObject *resultobj;
7930     wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7931     int result;
7932     PyObject * obj0 = 0 ;
7933     char *kwnames[] = {
7934         (char *) "self", NULL
7935     };
7936
7937     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetWidth",kwnames,&obj0)) goto fail;
7938     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7939     if (SWIG_arg_fail(1)) SWIG_fail;
7940     {
7941         PyThreadState* __tstate = wxPyBeginAllowThreads();
7942         result = (int)(arg1)->GetWidth();
7943
7944         wxPyEndAllowThreads(__tstate);
7945         if (PyErr_Occurred()) SWIG_fail;
7946     }
7947     {
7948         resultobj = SWIG_From_int((int)(result));
7949     }
7950     return resultobj;
7951     fail:
7952     return NULL;
7953 }
7954
7955
7956 static PyObject *_wrap_RegionIterator_GetH(PyObject *, PyObject *args, PyObject *kwargs) {
7957     PyObject *resultobj;
7958     wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7959     int result;
7960     PyObject * obj0 = 0 ;
7961     char *kwnames[] = {
7962         (char *) "self", NULL
7963     };
7964
7965     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetH",kwnames,&obj0)) goto fail;
7966     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7967     if (SWIG_arg_fail(1)) SWIG_fail;
7968     {
7969         PyThreadState* __tstate = wxPyBeginAllowThreads();
7970         result = (int)(arg1)->GetH();
7971
7972         wxPyEndAllowThreads(__tstate);
7973         if (PyErr_Occurred()) SWIG_fail;
7974     }
7975     {
7976         resultobj = SWIG_From_int((int)(result));
7977     }
7978     return resultobj;
7979     fail:
7980     return NULL;
7981 }
7982
7983
7984 static PyObject *_wrap_RegionIterator_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
7985     PyObject *resultobj;
7986     wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7987     int result;
7988     PyObject * obj0 = 0 ;
7989     char *kwnames[] = {
7990         (char *) "self", NULL
7991     };
7992
7993     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetHeight",kwnames,&obj0)) goto fail;
7994     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7995     if (SWIG_arg_fail(1)) SWIG_fail;
7996     {
7997         PyThreadState* __tstate = wxPyBeginAllowThreads();
7998         result = (int)(arg1)->GetHeight();
7999
8000         wxPyEndAllowThreads(__tstate);
8001         if (PyErr_Occurred()) SWIG_fail;
8002     }
8003     {
8004         resultobj = SWIG_From_int((int)(result));
8005     }
8006     return resultobj;
8007     fail:
8008     return NULL;
8009 }
8010
8011
8012 static PyObject *_wrap_RegionIterator_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
8013     PyObject *resultobj;
8014     wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8015     wxRect result;
8016     PyObject * obj0 = 0 ;
8017     char *kwnames[] = {
8018         (char *) "self", NULL
8019     };
8020
8021     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetRect",kwnames,&obj0)) goto fail;
8022     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8023     if (SWIG_arg_fail(1)) SWIG_fail;
8024     {
8025         PyThreadState* __tstate = wxPyBeginAllowThreads();
8026         result = (arg1)->GetRect();
8027
8028         wxPyEndAllowThreads(__tstate);
8029         if (PyErr_Occurred()) SWIG_fail;
8030     }
8031     {
8032         wxRect * resultptr;
8033         resultptr = new wxRect((wxRect &)(result));
8034         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
8035     }
8036     return resultobj;
8037     fail:
8038     return NULL;
8039 }
8040
8041
8042 static PyObject *_wrap_RegionIterator_HaveRects(PyObject *, PyObject *args, PyObject *kwargs) {
8043     PyObject *resultobj;
8044     wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8045     bool result;
8046     PyObject * obj0 = 0 ;
8047     char *kwnames[] = {
8048         (char *) "self", NULL
8049     };
8050
8051     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_HaveRects",kwnames,&obj0)) goto fail;
8052     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8053     if (SWIG_arg_fail(1)) SWIG_fail;
8054     {
8055         PyThreadState* __tstate = wxPyBeginAllowThreads();
8056         result = (bool)(arg1)->HaveRects();
8057
8058         wxPyEndAllowThreads(__tstate);
8059         if (PyErr_Occurred()) SWIG_fail;
8060     }
8061     {
8062         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8063     }
8064     return resultobj;
8065     fail:
8066     return NULL;
8067 }
8068
8069
8070 static PyObject *_wrap_RegionIterator_Reset(PyObject *, PyObject *args, PyObject *kwargs) {
8071     PyObject *resultobj;
8072     wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8073     PyObject * obj0 = 0 ;
8074     char *kwnames[] = {
8075         (char *) "self", NULL
8076     };
8077
8078     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Reset",kwnames,&obj0)) goto fail;
8079     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8080     if (SWIG_arg_fail(1)) SWIG_fail;
8081     {
8082         PyThreadState* __tstate = wxPyBeginAllowThreads();
8083         (arg1)->Reset();
8084
8085         wxPyEndAllowThreads(__tstate);
8086         if (PyErr_Occurred()) SWIG_fail;
8087     }
8088     Py_INCREF(Py_None); resultobj = Py_None;
8089     return resultobj;
8090     fail:
8091     return NULL;
8092 }
8093
8094
8095 static PyObject *_wrap_RegionIterator_Next(PyObject *, PyObject *args, PyObject *kwargs) {
8096     PyObject *resultobj;
8097     wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8098     PyObject * obj0 = 0 ;
8099     char *kwnames[] = {
8100         (char *) "self", NULL
8101     };
8102
8103     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Next",kwnames,&obj0)) goto fail;
8104     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8105     if (SWIG_arg_fail(1)) SWIG_fail;
8106     {
8107         PyThreadState* __tstate = wxPyBeginAllowThreads();
8108         wxRegionIterator_Next(arg1);
8109
8110         wxPyEndAllowThreads(__tstate);
8111         if (PyErr_Occurred()) SWIG_fail;
8112     }
8113     Py_INCREF(Py_None); resultobj = Py_None;
8114     return resultobj;
8115     fail:
8116     return NULL;
8117 }
8118
8119
8120 static PyObject *_wrap_RegionIterator___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
8121     PyObject *resultobj;
8122     wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8123     bool result;
8124     PyObject * obj0 = 0 ;
8125     char *kwnames[] = {
8126         (char *) "self", NULL
8127     };
8128
8129     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator___nonzero__",kwnames,&obj0)) goto fail;
8130     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8131     if (SWIG_arg_fail(1)) SWIG_fail;
8132     {
8133         PyThreadState* __tstate = wxPyBeginAllowThreads();
8134         result = (bool)wxRegionIterator___nonzero__(arg1);
8135
8136         wxPyEndAllowThreads(__tstate);
8137         if (PyErr_Occurred()) SWIG_fail;
8138     }
8139     {
8140         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8141     }
8142     return resultobj;
8143     fail:
8144     return NULL;
8145 }
8146
8147
8148 static PyObject * RegionIterator_swigregister(PyObject *, PyObject *args) {
8149     PyObject *obj;
8150     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8151     SWIG_TypeClientData(SWIGTYPE_p_wxRegionIterator, obj);
8152     Py_INCREF(obj);
8153     return Py_BuildValue((char *)"");
8154 }
8155 static PyObject *_wrap_new_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8156     PyObject *resultobj;
8157     wxNativeFontInfo *result;
8158     char *kwnames[] = {
8159         NULL
8160     };
8161
8162     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeFontInfo",kwnames)) goto fail;
8163     {
8164         PyThreadState* __tstate = wxPyBeginAllowThreads();
8165         result = (wxNativeFontInfo *)new wxNativeFontInfo();
8166
8167         wxPyEndAllowThreads(__tstate);
8168         if (PyErr_Occurred()) SWIG_fail;
8169     }
8170     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 1);
8171     return resultobj;
8172     fail:
8173     return NULL;
8174 }
8175
8176
8177 static PyObject *_wrap_delete_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8178     PyObject *resultobj;
8179     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8180     PyObject * obj0 = 0 ;
8181     char *kwnames[] = {
8182         (char *) "self", NULL
8183     };
8184
8185     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeFontInfo",kwnames,&obj0)) goto fail;
8186     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8187     if (SWIG_arg_fail(1)) SWIG_fail;
8188     {
8189         PyThreadState* __tstate = wxPyBeginAllowThreads();
8190         delete arg1;
8191
8192         wxPyEndAllowThreads(__tstate);
8193         if (PyErr_Occurred()) SWIG_fail;
8194     }
8195     Py_INCREF(Py_None); resultobj = Py_None;
8196     return resultobj;
8197     fail:
8198     return NULL;
8199 }
8200
8201
8202 static PyObject *_wrap_NativeFontInfo_Init(PyObject *, PyObject *args, PyObject *kwargs) {
8203     PyObject *resultobj;
8204     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8205     PyObject * obj0 = 0 ;
8206     char *kwnames[] = {
8207         (char *) "self", NULL
8208     };
8209
8210     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_Init",kwnames,&obj0)) goto fail;
8211     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8212     if (SWIG_arg_fail(1)) SWIG_fail;
8213     {
8214         PyThreadState* __tstate = wxPyBeginAllowThreads();
8215         (arg1)->Init();
8216
8217         wxPyEndAllowThreads(__tstate);
8218         if (PyErr_Occurred()) SWIG_fail;
8219     }
8220     Py_INCREF(Py_None); resultobj = Py_None;
8221     return resultobj;
8222     fail:
8223     return NULL;
8224 }
8225
8226
8227 static PyObject *_wrap_NativeFontInfo_InitFromFont(PyObject *, PyObject *args, PyObject *kwargs) {
8228     PyObject *resultobj;
8229     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8230     wxFont *arg2 = 0 ;
8231     PyObject * obj0 = 0 ;
8232     PyObject * obj1 = 0 ;
8233     char *kwnames[] = {
8234         (char *) "self",(char *) "font", NULL
8235     };
8236
8237     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_InitFromFont",kwnames,&obj0,&obj1)) goto fail;
8238     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8239     if (SWIG_arg_fail(1)) SWIG_fail;
8240     {
8241         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
8242         if (SWIG_arg_fail(2)) SWIG_fail;
8243         if (arg2 == NULL) {
8244             SWIG_null_ref("wxFont");
8245         }
8246         if (SWIG_arg_fail(2)) SWIG_fail;
8247     }
8248     {
8249         PyThreadState* __tstate = wxPyBeginAllowThreads();
8250         (arg1)->InitFromFont((wxFont const &)*arg2);
8251
8252         wxPyEndAllowThreads(__tstate);
8253         if (PyErr_Occurred()) SWIG_fail;
8254     }
8255     Py_INCREF(Py_None); resultobj = Py_None;
8256     return resultobj;
8257     fail:
8258     return NULL;
8259 }
8260
8261
8262 static PyObject *_wrap_NativeFontInfo_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
8263     PyObject *resultobj;
8264     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8265     int result;
8266     PyObject * obj0 = 0 ;
8267     char *kwnames[] = {
8268         (char *) "self", NULL
8269     };
8270
8271     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetPointSize",kwnames,&obj0)) 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         PyThreadState* __tstate = wxPyBeginAllowThreads();
8276         result = (int)((wxNativeFontInfo const *)arg1)->GetPointSize();
8277
8278         wxPyEndAllowThreads(__tstate);
8279         if (PyErr_Occurred()) SWIG_fail;
8280     }
8281     {
8282         resultobj = SWIG_From_int((int)(result));
8283     }
8284     return resultobj;
8285     fail:
8286     return NULL;
8287 }
8288
8289
8290 static PyObject *_wrap_NativeFontInfo_GetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
8291     PyObject *resultobj;
8292     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8293     wxSize result;
8294     PyObject * obj0 = 0 ;
8295     char *kwnames[] = {
8296         (char *) "self", NULL
8297     };
8298
8299     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetPixelSize",kwnames,&obj0)) goto fail;
8300     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8301     if (SWIG_arg_fail(1)) SWIG_fail;
8302     {
8303         PyThreadState* __tstate = wxPyBeginAllowThreads();
8304         result = ((wxNativeFontInfo const *)arg1)->GetPixelSize();
8305
8306         wxPyEndAllowThreads(__tstate);
8307         if (PyErr_Occurred()) SWIG_fail;
8308     }
8309     {
8310         wxSize * resultptr;
8311         resultptr = new wxSize((wxSize &)(result));
8312         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
8313     }
8314     return resultobj;
8315     fail:
8316     return NULL;
8317 }
8318
8319
8320 static PyObject *_wrap_NativeFontInfo_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
8321     PyObject *resultobj;
8322     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8323     wxFontStyle result;
8324     PyObject * obj0 = 0 ;
8325     char *kwnames[] = {
8326         (char *) "self", NULL
8327     };
8328
8329     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetStyle",kwnames,&obj0)) goto fail;
8330     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8331     if (SWIG_arg_fail(1)) SWIG_fail;
8332     {
8333         PyThreadState* __tstate = wxPyBeginAllowThreads();
8334         result = (wxFontStyle)((wxNativeFontInfo const *)arg1)->GetStyle();
8335
8336         wxPyEndAllowThreads(__tstate);
8337         if (PyErr_Occurred()) SWIG_fail;
8338     }
8339     resultobj = SWIG_From_int((result));
8340     return resultobj;
8341     fail:
8342     return NULL;
8343 }
8344
8345
8346 static PyObject *_wrap_NativeFontInfo_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
8347     PyObject *resultobj;
8348     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8349     wxFontWeight result;
8350     PyObject * obj0 = 0 ;
8351     char *kwnames[] = {
8352         (char *) "self", NULL
8353     };
8354
8355     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetWeight",kwnames,&obj0)) goto fail;
8356     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8357     if (SWIG_arg_fail(1)) SWIG_fail;
8358     {
8359         PyThreadState* __tstate = wxPyBeginAllowThreads();
8360         result = (wxFontWeight)((wxNativeFontInfo const *)arg1)->GetWeight();
8361
8362         wxPyEndAllowThreads(__tstate);
8363         if (PyErr_Occurred()) SWIG_fail;
8364     }
8365     resultobj = SWIG_From_int((result));
8366     return resultobj;
8367     fail:
8368     return NULL;
8369 }
8370
8371
8372 static PyObject *_wrap_NativeFontInfo_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
8373     PyObject *resultobj;
8374     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8375     bool result;
8376     PyObject * obj0 = 0 ;
8377     char *kwnames[] = {
8378         (char *) "self", NULL
8379     };
8380
8381     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetUnderlined",kwnames,&obj0)) goto fail;
8382     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8383     if (SWIG_arg_fail(1)) SWIG_fail;
8384     {
8385         PyThreadState* __tstate = wxPyBeginAllowThreads();
8386         result = (bool)((wxNativeFontInfo const *)arg1)->GetUnderlined();
8387
8388         wxPyEndAllowThreads(__tstate);
8389         if (PyErr_Occurred()) SWIG_fail;
8390     }
8391     {
8392         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8393     }
8394     return resultobj;
8395     fail:
8396     return NULL;
8397 }
8398
8399
8400 static PyObject *_wrap_NativeFontInfo_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
8401     PyObject *resultobj;
8402     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8403     wxString result;
8404     PyObject * obj0 = 0 ;
8405     char *kwnames[] = {
8406         (char *) "self", NULL
8407     };
8408
8409     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFaceName",kwnames,&obj0)) goto fail;
8410     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8411     if (SWIG_arg_fail(1)) SWIG_fail;
8412     {
8413         PyThreadState* __tstate = wxPyBeginAllowThreads();
8414         result = ((wxNativeFontInfo const *)arg1)->GetFaceName();
8415
8416         wxPyEndAllowThreads(__tstate);
8417         if (PyErr_Occurred()) SWIG_fail;
8418     }
8419     {
8420 #if wxUSE_UNICODE
8421         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8422 #else
8423         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8424 #endif
8425     }
8426     return resultobj;
8427     fail:
8428     return NULL;
8429 }
8430
8431
8432 static PyObject *_wrap_NativeFontInfo_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
8433     PyObject *resultobj;
8434     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8435     wxFontFamily result;
8436     PyObject * obj0 = 0 ;
8437     char *kwnames[] = {
8438         (char *) "self", NULL
8439     };
8440
8441     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFamily",kwnames,&obj0)) goto fail;
8442     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8443     if (SWIG_arg_fail(1)) SWIG_fail;
8444     {
8445         PyThreadState* __tstate = wxPyBeginAllowThreads();
8446         result = (wxFontFamily)((wxNativeFontInfo const *)arg1)->GetFamily();
8447
8448         wxPyEndAllowThreads(__tstate);
8449         if (PyErr_Occurred()) SWIG_fail;
8450     }
8451     resultobj = SWIG_From_int((result));
8452     return resultobj;
8453     fail:
8454     return NULL;
8455 }
8456
8457
8458 static PyObject *_wrap_NativeFontInfo_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8459     PyObject *resultobj;
8460     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8461     wxFontEncoding result;
8462     PyObject * obj0 = 0 ;
8463     char *kwnames[] = {
8464         (char *) "self", NULL
8465     };
8466
8467     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetEncoding",kwnames,&obj0)) goto fail;
8468     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8469     if (SWIG_arg_fail(1)) SWIG_fail;
8470     {
8471         PyThreadState* __tstate = wxPyBeginAllowThreads();
8472         result = (wxFontEncoding)((wxNativeFontInfo const *)arg1)->GetEncoding();
8473
8474         wxPyEndAllowThreads(__tstate);
8475         if (PyErr_Occurred()) SWIG_fail;
8476     }
8477     resultobj = SWIG_From_int((result));
8478     return resultobj;
8479     fail:
8480     return NULL;
8481 }
8482
8483
8484 static PyObject *_wrap_NativeFontInfo_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
8485     PyObject *resultobj;
8486     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8487     int arg2 ;
8488     PyObject * obj0 = 0 ;
8489     PyObject * obj1 = 0 ;
8490     char *kwnames[] = {
8491         (char *) "self",(char *) "pointsize", NULL
8492     };
8493
8494     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
8495     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8496     if (SWIG_arg_fail(1)) SWIG_fail;
8497     {
8498         arg2 = (int)(SWIG_As_int(obj1));
8499         if (SWIG_arg_fail(2)) SWIG_fail;
8500     }
8501     {
8502         PyThreadState* __tstate = wxPyBeginAllowThreads();
8503         (arg1)->SetPointSize(arg2);
8504
8505         wxPyEndAllowThreads(__tstate);
8506         if (PyErr_Occurred()) SWIG_fail;
8507     }
8508     Py_INCREF(Py_None); resultobj = Py_None;
8509     return resultobj;
8510     fail:
8511     return NULL;
8512 }
8513
8514
8515 static PyObject *_wrap_NativeFontInfo_SetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
8516     PyObject *resultobj;
8517     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8518     wxSize *arg2 = 0 ;
8519     wxSize temp2 ;
8520     PyObject * obj0 = 0 ;
8521     PyObject * obj1 = 0 ;
8522     char *kwnames[] = {
8523         (char *) "self",(char *) "pixelSize", NULL
8524     };
8525
8526     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPixelSize",kwnames,&obj0,&obj1)) goto fail;
8527     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8528     if (SWIG_arg_fail(1)) SWIG_fail;
8529     {
8530         arg2 = &temp2;
8531         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8532     }
8533     {
8534         PyThreadState* __tstate = wxPyBeginAllowThreads();
8535         (arg1)->SetPixelSize((wxSize const &)*arg2);
8536
8537         wxPyEndAllowThreads(__tstate);
8538         if (PyErr_Occurred()) SWIG_fail;
8539     }
8540     Py_INCREF(Py_None); resultobj = Py_None;
8541     return resultobj;
8542     fail:
8543     return NULL;
8544 }
8545
8546
8547 static PyObject *_wrap_NativeFontInfo_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
8548     PyObject *resultobj;
8549     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8550     wxFontStyle arg2 ;
8551     PyObject * obj0 = 0 ;
8552     PyObject * obj1 = 0 ;
8553     char *kwnames[] = {
8554         (char *) "self",(char *) "style", NULL
8555     };
8556
8557     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetStyle",kwnames,&obj0,&obj1)) goto fail;
8558     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8559     if (SWIG_arg_fail(1)) SWIG_fail;
8560     {
8561         arg2 = (wxFontStyle)(SWIG_As_int(obj1));
8562         if (SWIG_arg_fail(2)) SWIG_fail;
8563     }
8564     {
8565         PyThreadState* __tstate = wxPyBeginAllowThreads();
8566         (arg1)->SetStyle((wxFontStyle )arg2);
8567
8568         wxPyEndAllowThreads(__tstate);
8569         if (PyErr_Occurred()) SWIG_fail;
8570     }
8571     Py_INCREF(Py_None); resultobj = Py_None;
8572     return resultobj;
8573     fail:
8574     return NULL;
8575 }
8576
8577
8578 static PyObject *_wrap_NativeFontInfo_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
8579     PyObject *resultobj;
8580     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8581     wxFontWeight arg2 ;
8582     PyObject * obj0 = 0 ;
8583     PyObject * obj1 = 0 ;
8584     char *kwnames[] = {
8585         (char *) "self",(char *) "weight", NULL
8586     };
8587
8588     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetWeight",kwnames,&obj0,&obj1)) goto fail;
8589     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8590     if (SWIG_arg_fail(1)) SWIG_fail;
8591     {
8592         arg2 = (wxFontWeight)(SWIG_As_int(obj1));
8593         if (SWIG_arg_fail(2)) SWIG_fail;
8594     }
8595     {
8596         PyThreadState* __tstate = wxPyBeginAllowThreads();
8597         (arg1)->SetWeight((wxFontWeight )arg2);
8598
8599         wxPyEndAllowThreads(__tstate);
8600         if (PyErr_Occurred()) SWIG_fail;
8601     }
8602     Py_INCREF(Py_None); resultobj = Py_None;
8603     return resultobj;
8604     fail:
8605     return NULL;
8606 }
8607
8608
8609 static PyObject *_wrap_NativeFontInfo_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
8610     PyObject *resultobj;
8611     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8612     bool arg2 ;
8613     PyObject * obj0 = 0 ;
8614     PyObject * obj1 = 0 ;
8615     char *kwnames[] = {
8616         (char *) "self",(char *) "underlined", NULL
8617     };
8618
8619     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
8620     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8621     if (SWIG_arg_fail(1)) SWIG_fail;
8622     {
8623         arg2 = (bool)(SWIG_As_bool(obj1));
8624         if (SWIG_arg_fail(2)) SWIG_fail;
8625     }
8626     {
8627         PyThreadState* __tstate = wxPyBeginAllowThreads();
8628         (arg1)->SetUnderlined(arg2);
8629
8630         wxPyEndAllowThreads(__tstate);
8631         if (PyErr_Occurred()) SWIG_fail;
8632     }
8633     Py_INCREF(Py_None); resultobj = Py_None;
8634     return resultobj;
8635     fail:
8636     return NULL;
8637 }
8638
8639
8640 static PyObject *_wrap_NativeFontInfo_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
8641     PyObject *resultobj;
8642     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8643     wxString arg2 ;
8644     PyObject * obj0 = 0 ;
8645     PyObject * obj1 = 0 ;
8646     char *kwnames[] = {
8647         (char *) "self",(char *) "facename", NULL
8648     };
8649
8650     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
8651     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8652     if (SWIG_arg_fail(1)) SWIG_fail;
8653     {
8654         wxString* sptr = wxString_in_helper(obj1);
8655         if (sptr == NULL) SWIG_fail;
8656         arg2 = *sptr;
8657         delete sptr;
8658     }
8659     {
8660         PyThreadState* __tstate = wxPyBeginAllowThreads();
8661         (arg1)->SetFaceName(arg2);
8662
8663         wxPyEndAllowThreads(__tstate);
8664         if (PyErr_Occurred()) SWIG_fail;
8665     }
8666     Py_INCREF(Py_None); resultobj = Py_None;
8667     return resultobj;
8668     fail:
8669     return NULL;
8670 }
8671
8672
8673 static PyObject *_wrap_NativeFontInfo_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
8674     PyObject *resultobj;
8675     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8676     wxFontFamily arg2 ;
8677     PyObject * obj0 = 0 ;
8678     PyObject * obj1 = 0 ;
8679     char *kwnames[] = {
8680         (char *) "self",(char *) "family", NULL
8681     };
8682
8683     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFamily",kwnames,&obj0,&obj1)) goto fail;
8684     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8685     if (SWIG_arg_fail(1)) SWIG_fail;
8686     {
8687         arg2 = (wxFontFamily)(SWIG_As_int(obj1));
8688         if (SWIG_arg_fail(2)) SWIG_fail;
8689     }
8690     {
8691         PyThreadState* __tstate = wxPyBeginAllowThreads();
8692         (arg1)->SetFamily((wxFontFamily )arg2);
8693
8694         wxPyEndAllowThreads(__tstate);
8695         if (PyErr_Occurred()) SWIG_fail;
8696     }
8697     Py_INCREF(Py_None); resultobj = Py_None;
8698     return resultobj;
8699     fail:
8700     return NULL;
8701 }
8702
8703
8704 static PyObject *_wrap_NativeFontInfo_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8705     PyObject *resultobj;
8706     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8707     wxFontEncoding arg2 ;
8708     PyObject * obj0 = 0 ;
8709     PyObject * obj1 = 0 ;
8710     char *kwnames[] = {
8711         (char *) "self",(char *) "encoding", NULL
8712     };
8713
8714     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
8715     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8716     if (SWIG_arg_fail(1)) SWIG_fail;
8717     {
8718         arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8719         if (SWIG_arg_fail(2)) SWIG_fail;
8720     }
8721     {
8722         PyThreadState* __tstate = wxPyBeginAllowThreads();
8723         (arg1)->SetEncoding((wxFontEncoding )arg2);
8724
8725         wxPyEndAllowThreads(__tstate);
8726         if (PyErr_Occurred()) SWIG_fail;
8727     }
8728     Py_INCREF(Py_None); resultobj = Py_None;
8729     return resultobj;
8730     fail:
8731     return NULL;
8732 }
8733
8734
8735 static PyObject *_wrap_NativeFontInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8736     PyObject *resultobj;
8737     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8738     wxString *arg2 = 0 ;
8739     bool result;
8740     bool temp2 = false ;
8741     PyObject * obj0 = 0 ;
8742     PyObject * obj1 = 0 ;
8743     char *kwnames[] = {
8744         (char *) "self",(char *) "s", NULL
8745     };
8746
8747     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8748     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8749     if (SWIG_arg_fail(1)) SWIG_fail;
8750     {
8751         arg2 = wxString_in_helper(obj1);
8752         if (arg2 == NULL) SWIG_fail;
8753         temp2 = true;
8754     }
8755     {
8756         PyThreadState* __tstate = wxPyBeginAllowThreads();
8757         result = (bool)(arg1)->FromString((wxString const &)*arg2);
8758
8759         wxPyEndAllowThreads(__tstate);
8760         if (PyErr_Occurred()) SWIG_fail;
8761     }
8762     {
8763         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8764     }
8765     {
8766         if (temp2)
8767         delete arg2;
8768     }
8769     return resultobj;
8770     fail:
8771     {
8772         if (temp2)
8773         delete arg2;
8774     }
8775     return NULL;
8776 }
8777
8778
8779 static PyObject *_wrap_NativeFontInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8780     PyObject *resultobj;
8781     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8782     wxString result;
8783     PyObject * obj0 = 0 ;
8784     char *kwnames[] = {
8785         (char *) "self", NULL
8786     };
8787
8788     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToString",kwnames,&obj0)) goto fail;
8789     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8790     if (SWIG_arg_fail(1)) SWIG_fail;
8791     {
8792         PyThreadState* __tstate = wxPyBeginAllowThreads();
8793         result = ((wxNativeFontInfo const *)arg1)->ToString();
8794
8795         wxPyEndAllowThreads(__tstate);
8796         if (PyErr_Occurred()) SWIG_fail;
8797     }
8798     {
8799 #if wxUSE_UNICODE
8800         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8801 #else
8802         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8803 #endif
8804     }
8805     return resultobj;
8806     fail:
8807     return NULL;
8808 }
8809
8810
8811 static PyObject *_wrap_NativeFontInfo___str__(PyObject *, PyObject *args, PyObject *kwargs) {
8812     PyObject *resultobj;
8813     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8814     wxString result;
8815     PyObject * obj0 = 0 ;
8816     char *kwnames[] = {
8817         (char *) "self", NULL
8818     };
8819
8820     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo___str__",kwnames,&obj0)) goto fail;
8821     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8822     if (SWIG_arg_fail(1)) SWIG_fail;
8823     {
8824         PyThreadState* __tstate = wxPyBeginAllowThreads();
8825         result = wxNativeFontInfo___str__(arg1);
8826
8827         wxPyEndAllowThreads(__tstate);
8828         if (PyErr_Occurred()) SWIG_fail;
8829     }
8830     {
8831 #if wxUSE_UNICODE
8832         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8833 #else
8834         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8835 #endif
8836     }
8837     return resultobj;
8838     fail:
8839     return NULL;
8840 }
8841
8842
8843 static PyObject *_wrap_NativeFontInfo_FromUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8844     PyObject *resultobj;
8845     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8846     wxString *arg2 = 0 ;
8847     bool result;
8848     bool temp2 = false ;
8849     PyObject * obj0 = 0 ;
8850     PyObject * obj1 = 0 ;
8851     char *kwnames[] = {
8852         (char *) "self",(char *) "s", NULL
8853     };
8854
8855     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromUserString",kwnames,&obj0,&obj1)) goto fail;
8856     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8857     if (SWIG_arg_fail(1)) SWIG_fail;
8858     {
8859         arg2 = wxString_in_helper(obj1);
8860         if (arg2 == NULL) SWIG_fail;
8861         temp2 = true;
8862     }
8863     {
8864         PyThreadState* __tstate = wxPyBeginAllowThreads();
8865         result = (bool)(arg1)->FromUserString((wxString const &)*arg2);
8866
8867         wxPyEndAllowThreads(__tstate);
8868         if (PyErr_Occurred()) SWIG_fail;
8869     }
8870     {
8871         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8872     }
8873     {
8874         if (temp2)
8875         delete arg2;
8876     }
8877     return resultobj;
8878     fail:
8879     {
8880         if (temp2)
8881         delete arg2;
8882     }
8883     return NULL;
8884 }
8885
8886
8887 static PyObject *_wrap_NativeFontInfo_ToUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8888     PyObject *resultobj;
8889     wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8890     wxString result;
8891     PyObject * obj0 = 0 ;
8892     char *kwnames[] = {
8893         (char *) "self", NULL
8894     };
8895
8896     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToUserString",kwnames,&obj0)) goto fail;
8897     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8898     if (SWIG_arg_fail(1)) SWIG_fail;
8899     {
8900         PyThreadState* __tstate = wxPyBeginAllowThreads();
8901         result = ((wxNativeFontInfo const *)arg1)->ToUserString();
8902
8903         wxPyEndAllowThreads(__tstate);
8904         if (PyErr_Occurred()) SWIG_fail;
8905     }
8906     {
8907 #if wxUSE_UNICODE
8908         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8909 #else
8910         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8911 #endif
8912     }
8913     return resultobj;
8914     fail:
8915     return NULL;
8916 }
8917
8918
8919 static PyObject * NativeFontInfo_swigregister(PyObject *, PyObject *args) {
8920     PyObject *obj;
8921     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8922     SWIG_TypeClientData(SWIGTYPE_p_wxNativeFontInfo, obj);
8923     Py_INCREF(obj);
8924     return Py_BuildValue((char *)"");
8925 }
8926 static PyObject *_wrap_NativeEncodingInfo_facename_set(PyObject *, PyObject *args, PyObject *kwargs) {
8927     PyObject *resultobj;
8928     wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8929     wxString *arg2 = (wxString *) 0 ;
8930     bool temp2 = false ;
8931     PyObject * obj0 = 0 ;
8932     PyObject * obj1 = 0 ;
8933     char *kwnames[] = {
8934         (char *) "self",(char *) "facename", NULL
8935     };
8936
8937     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_facename_set",kwnames,&obj0,&obj1)) goto fail;
8938     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8939     if (SWIG_arg_fail(1)) SWIG_fail;
8940     {
8941         arg2 = wxString_in_helper(obj1);
8942         if (arg2 == NULL) SWIG_fail;
8943         temp2 = true;
8944     }
8945     if (arg1) (arg1)->facename = *arg2;
8946
8947     Py_INCREF(Py_None); resultobj = Py_None;
8948     {
8949         if (temp2)
8950         delete arg2;
8951     }
8952     return resultobj;
8953     fail:
8954     {
8955         if (temp2)
8956         delete arg2;
8957     }
8958     return NULL;
8959 }
8960
8961
8962 static PyObject *_wrap_NativeEncodingInfo_facename_get(PyObject *, PyObject *args, PyObject *kwargs) {
8963     PyObject *resultobj;
8964     wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8965     wxString *result;
8966     PyObject * obj0 = 0 ;
8967     char *kwnames[] = {
8968         (char *) "self", NULL
8969     };
8970
8971     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_facename_get",kwnames,&obj0)) 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     result = (wxString *)& ((arg1)->facename);
8975
8976     {
8977 #if wxUSE_UNICODE
8978         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8979 #else
8980         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8981 #endif
8982     }
8983     return resultobj;
8984     fail:
8985     return NULL;
8986 }
8987
8988
8989 static PyObject *_wrap_NativeEncodingInfo_encoding_set(PyObject *, PyObject *args, PyObject *kwargs) {
8990     PyObject *resultobj;
8991     wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8992     wxFontEncoding arg2 ;
8993     PyObject * obj0 = 0 ;
8994     PyObject * obj1 = 0 ;
8995     char *kwnames[] = {
8996         (char *) "self",(char *) "encoding", NULL
8997     };
8998
8999     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_encoding_set",kwnames,&obj0,&obj1)) goto fail;
9000     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9001     if (SWIG_arg_fail(1)) SWIG_fail;
9002     {
9003         arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9004         if (SWIG_arg_fail(2)) SWIG_fail;
9005     }
9006     if (arg1) (arg1)->encoding = (wxFontEncoding )arg2;
9007
9008     Py_INCREF(Py_None); resultobj = Py_None;
9009     return resultobj;
9010     fail:
9011     return NULL;
9012 }
9013
9014
9015 static PyObject *_wrap_NativeEncodingInfo_encoding_get(PyObject *, PyObject *args, PyObject *kwargs) {
9016     PyObject *resultobj;
9017     wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9018     wxFontEncoding result;
9019     PyObject * obj0 = 0 ;
9020     char *kwnames[] = {
9021         (char *) "self", NULL
9022     };
9023
9024     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_encoding_get",kwnames,&obj0)) goto fail;
9025     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9026     if (SWIG_arg_fail(1)) SWIG_fail;
9027     result = (wxFontEncoding) ((arg1)->encoding);
9028
9029     resultobj = SWIG_From_int((result));
9030     return resultobj;
9031     fail:
9032     return NULL;
9033 }
9034
9035
9036 static PyObject *_wrap_new_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9037     PyObject *resultobj;
9038     wxNativeEncodingInfo *result;
9039     char *kwnames[] = {
9040         NULL
9041     };
9042
9043     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeEncodingInfo",kwnames)) goto fail;
9044     {
9045         PyThreadState* __tstate = wxPyBeginAllowThreads();
9046         result = (wxNativeEncodingInfo *)new wxNativeEncodingInfo();
9047
9048         wxPyEndAllowThreads(__tstate);
9049         if (PyErr_Occurred()) SWIG_fail;
9050     }
9051     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 1);
9052     return resultobj;
9053     fail:
9054     return NULL;
9055 }
9056
9057
9058 static PyObject *_wrap_delete_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9059     PyObject *resultobj;
9060     wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9061     PyObject * obj0 = 0 ;
9062     char *kwnames[] = {
9063         (char *) "self", NULL
9064     };
9065
9066     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeEncodingInfo",kwnames,&obj0)) goto fail;
9067     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9068     if (SWIG_arg_fail(1)) SWIG_fail;
9069     {
9070         PyThreadState* __tstate = wxPyBeginAllowThreads();
9071         delete arg1;
9072
9073         wxPyEndAllowThreads(__tstate);
9074         if (PyErr_Occurred()) SWIG_fail;
9075     }
9076     Py_INCREF(Py_None); resultobj = Py_None;
9077     return resultobj;
9078     fail:
9079     return NULL;
9080 }
9081
9082
9083 static PyObject *_wrap_NativeEncodingInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
9084     PyObject *resultobj;
9085     wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9086     wxString *arg2 = 0 ;
9087     bool result;
9088     bool temp2 = false ;
9089     PyObject * obj0 = 0 ;
9090     PyObject * obj1 = 0 ;
9091     char *kwnames[] = {
9092         (char *) "self",(char *) "s", NULL
9093     };
9094
9095     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
9096     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9097     if (SWIG_arg_fail(1)) SWIG_fail;
9098     {
9099         arg2 = wxString_in_helper(obj1);
9100         if (arg2 == NULL) SWIG_fail;
9101         temp2 = true;
9102     }
9103     {
9104         PyThreadState* __tstate = wxPyBeginAllowThreads();
9105         result = (bool)(arg1)->FromString((wxString const &)*arg2);
9106
9107         wxPyEndAllowThreads(__tstate);
9108         if (PyErr_Occurred()) SWIG_fail;
9109     }
9110     {
9111         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9112     }
9113     {
9114         if (temp2)
9115         delete arg2;
9116     }
9117     return resultobj;
9118     fail:
9119     {
9120         if (temp2)
9121         delete arg2;
9122     }
9123     return NULL;
9124 }
9125
9126
9127 static PyObject *_wrap_NativeEncodingInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
9128     PyObject *resultobj;
9129     wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9130     wxString result;
9131     PyObject * obj0 = 0 ;
9132     char *kwnames[] = {
9133         (char *) "self", NULL
9134     };
9135
9136     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_ToString",kwnames,&obj0)) goto fail;
9137     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9138     if (SWIG_arg_fail(1)) SWIG_fail;
9139     {
9140         PyThreadState* __tstate = wxPyBeginAllowThreads();
9141         result = ((wxNativeEncodingInfo const *)arg1)->ToString();
9142
9143         wxPyEndAllowThreads(__tstate);
9144         if (PyErr_Occurred()) SWIG_fail;
9145     }
9146     {
9147 #if wxUSE_UNICODE
9148         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9149 #else
9150         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9151 #endif
9152     }
9153     return resultobj;
9154     fail:
9155     return NULL;
9156 }
9157
9158
9159 static PyObject * NativeEncodingInfo_swigregister(PyObject *, PyObject *args) {
9160     PyObject *obj;
9161     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9162     SWIG_TypeClientData(SWIGTYPE_p_wxNativeEncodingInfo, obj);
9163     Py_INCREF(obj);
9164     return Py_BuildValue((char *)"");
9165 }
9166 static PyObject *_wrap_GetNativeFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9167     PyObject *resultobj;
9168     wxFontEncoding arg1 ;
9169     wxNativeEncodingInfo *result;
9170     PyObject * obj0 = 0 ;
9171     char *kwnames[] = {
9172         (char *) "encoding", NULL
9173     };
9174
9175     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetNativeFontEncoding",kwnames,&obj0)) goto fail;
9176     {
9177         arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
9178         if (SWIG_arg_fail(1)) SWIG_fail;
9179     }
9180     {
9181         PyThreadState* __tstate = wxPyBeginAllowThreads();
9182         result = (wxNativeEncodingInfo *)wxGetNativeFontEncoding((wxFontEncoding )arg1);
9183
9184         wxPyEndAllowThreads(__tstate);
9185         if (PyErr_Occurred()) SWIG_fail;
9186     }
9187     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 0);
9188     return resultobj;
9189     fail:
9190     return NULL;
9191 }
9192
9193
9194 static PyObject *_wrap_TestFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9195     PyObject *resultobj;
9196     wxNativeEncodingInfo *arg1 = 0 ;
9197     bool result;
9198     PyObject * obj0 = 0 ;
9199     char *kwnames[] = {
9200         (char *) "info", NULL
9201     };
9202
9203     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TestFontEncoding",kwnames,&obj0)) goto fail;
9204     {
9205         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9206         if (SWIG_arg_fail(1)) SWIG_fail;
9207         if (arg1 == NULL) {
9208             SWIG_null_ref("wxNativeEncodingInfo");
9209         }
9210         if (SWIG_arg_fail(1)) SWIG_fail;
9211     }
9212     {
9213         PyThreadState* __tstate = wxPyBeginAllowThreads();
9214         result = (bool)wxTestFontEncoding((wxNativeEncodingInfo const &)*arg1);
9215
9216         wxPyEndAllowThreads(__tstate);
9217         if (PyErr_Occurred()) SWIG_fail;
9218     }
9219     {
9220         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9221     }
9222     return resultobj;
9223     fail:
9224     return NULL;
9225 }
9226
9227
9228 static PyObject *_wrap_new_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
9229     PyObject *resultobj;
9230     wxFontMapper *result;
9231     char *kwnames[] = {
9232         NULL
9233     };
9234
9235     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontMapper",kwnames)) goto fail;
9236     {
9237         PyThreadState* __tstate = wxPyBeginAllowThreads();
9238         result = (wxFontMapper *)new wxFontMapper();
9239
9240         wxPyEndAllowThreads(__tstate);
9241         if (PyErr_Occurred()) SWIG_fail;
9242     }
9243     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 1);
9244     return resultobj;
9245     fail:
9246     return NULL;
9247 }
9248
9249
9250 static PyObject *_wrap_delete_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
9251     PyObject *resultobj;
9252     wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9253     PyObject * obj0 = 0 ;
9254     char *kwnames[] = {
9255         (char *) "self", NULL
9256     };
9257
9258     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontMapper",kwnames,&obj0)) goto fail;
9259     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9260     if (SWIG_arg_fail(1)) SWIG_fail;
9261     {
9262         PyThreadState* __tstate = wxPyBeginAllowThreads();
9263         delete arg1;
9264
9265         wxPyEndAllowThreads(__tstate);
9266         if (PyErr_Occurred()) SWIG_fail;
9267     }
9268     Py_INCREF(Py_None); resultobj = Py_None;
9269     return resultobj;
9270     fail:
9271     return NULL;
9272 }
9273
9274
9275 static PyObject *_wrap_FontMapper_Get(PyObject *, PyObject *args, PyObject *kwargs) {
9276     PyObject *resultobj;
9277     wxFontMapper *result;
9278     char *kwnames[] = {
9279         NULL
9280     };
9281
9282     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_Get",kwnames)) goto fail;
9283     {
9284         PyThreadState* __tstate = wxPyBeginAllowThreads();
9285         result = (wxFontMapper *)wxFontMapper::Get();
9286
9287         wxPyEndAllowThreads(__tstate);
9288         if (PyErr_Occurred()) SWIG_fail;
9289     }
9290     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
9291     return resultobj;
9292     fail:
9293     return NULL;
9294 }
9295
9296
9297 static PyObject *_wrap_FontMapper_Set(PyObject *, PyObject *args, PyObject *kwargs) {
9298     PyObject *resultobj;
9299     wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9300     wxFontMapper *result;
9301     PyObject * obj0 = 0 ;
9302     char *kwnames[] = {
9303         (char *) "mapper", NULL
9304     };
9305
9306     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_Set",kwnames,&obj0)) goto fail;
9307     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9308     if (SWIG_arg_fail(1)) SWIG_fail;
9309     {
9310         PyThreadState* __tstate = wxPyBeginAllowThreads();
9311         result = (wxFontMapper *)wxFontMapper::Set(arg1);
9312
9313         wxPyEndAllowThreads(__tstate);
9314         if (PyErr_Occurred()) SWIG_fail;
9315     }
9316     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
9317     return resultobj;
9318     fail:
9319     return NULL;
9320 }
9321
9322
9323 static PyObject *_wrap_FontMapper_CharsetToEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9324     PyObject *resultobj;
9325     wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9326     wxString *arg2 = 0 ;
9327     bool arg3 = (bool) true ;
9328     wxFontEncoding result;
9329     bool temp2 = false ;
9330     PyObject * obj0 = 0 ;
9331     PyObject * obj1 = 0 ;
9332     PyObject * obj2 = 0 ;
9333     char *kwnames[] = {
9334         (char *) "self",(char *) "charset",(char *) "interactive", NULL
9335     };
9336
9337     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_CharsetToEncoding",kwnames,&obj0,&obj1,&obj2)) goto fail;
9338     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9339     if (SWIG_arg_fail(1)) SWIG_fail;
9340     {
9341         arg2 = wxString_in_helper(obj1);
9342         if (arg2 == NULL) SWIG_fail;
9343         temp2 = true;
9344     }
9345     if (obj2) {
9346         {
9347             arg3 = (bool)(SWIG_As_bool(obj2));
9348             if (SWIG_arg_fail(3)) SWIG_fail;
9349         }
9350     }
9351     {
9352         PyThreadState* __tstate = wxPyBeginAllowThreads();
9353         result = (wxFontEncoding)(arg1)->CharsetToEncoding((wxString const &)*arg2,arg3);
9354
9355         wxPyEndAllowThreads(__tstate);
9356         if (PyErr_Occurred()) SWIG_fail;
9357     }
9358     resultobj = SWIG_From_int((result));
9359     {
9360         if (temp2)
9361         delete arg2;
9362     }
9363     return resultobj;
9364     fail:
9365     {
9366         if (temp2)
9367         delete arg2;
9368     }
9369     return NULL;
9370 }
9371
9372
9373 static PyObject *_wrap_FontMapper_GetSupportedEncodingsCount(PyObject *, PyObject *args, PyObject *kwargs) {
9374     PyObject *resultobj;
9375     size_t result;
9376     char *kwnames[] = {
9377         NULL
9378     };
9379
9380     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetSupportedEncodingsCount",kwnames)) goto fail;
9381     {
9382         PyThreadState* __tstate = wxPyBeginAllowThreads();
9383         result = (size_t)wxFontMapper::GetSupportedEncodingsCount();
9384
9385         wxPyEndAllowThreads(__tstate);
9386         if (PyErr_Occurred()) SWIG_fail;
9387     }
9388     {
9389         resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9390     }
9391     return resultobj;
9392     fail:
9393     return NULL;
9394 }
9395
9396
9397 static PyObject *_wrap_FontMapper_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9398     PyObject *resultobj;
9399     size_t arg1 ;
9400     wxFontEncoding result;
9401     PyObject * obj0 = 0 ;
9402     char *kwnames[] = {
9403         (char *) "n", NULL
9404     };
9405
9406     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncoding",kwnames,&obj0)) goto fail;
9407     {
9408         arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
9409         if (SWIG_arg_fail(1)) SWIG_fail;
9410     }
9411     {
9412         PyThreadState* __tstate = wxPyBeginAllowThreads();
9413         result = (wxFontEncoding)wxFontMapper::GetEncoding(arg1);
9414
9415         wxPyEndAllowThreads(__tstate);
9416         if (PyErr_Occurred()) SWIG_fail;
9417     }
9418     resultobj = SWIG_From_int((result));
9419     return resultobj;
9420     fail:
9421     return NULL;
9422 }
9423
9424
9425 static PyObject *_wrap_FontMapper_GetEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
9426     PyObject *resultobj;
9427     wxFontEncoding arg1 ;
9428     wxString result;
9429     PyObject * obj0 = 0 ;
9430     char *kwnames[] = {
9431         (char *) "encoding", NULL
9432     };
9433
9434     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingName",kwnames,&obj0)) goto fail;
9435     {
9436         arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
9437         if (SWIG_arg_fail(1)) SWIG_fail;
9438     }
9439     {
9440         PyThreadState* __tstate = wxPyBeginAllowThreads();
9441         result = wxFontMapper::GetEncodingName((wxFontEncoding )arg1);
9442
9443         wxPyEndAllowThreads(__tstate);
9444         if (PyErr_Occurred()) SWIG_fail;
9445     }
9446     {
9447 #if wxUSE_UNICODE
9448         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9449 #else
9450         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9451 #endif
9452     }
9453     return resultobj;
9454     fail:
9455     return NULL;
9456 }
9457
9458
9459 static PyObject *_wrap_FontMapper_GetEncodingDescription(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_GetEncodingDescription",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::GetEncodingDescription((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_GetEncodingFromName(PyObject *, PyObject *args, PyObject *kwargs) {
9494     PyObject *resultobj;
9495     wxString *arg1 = 0 ;
9496     wxFontEncoding result;
9497     bool temp1 = false ;
9498     PyObject * obj0 = 0 ;
9499     char *kwnames[] = {
9500         (char *) "name", NULL
9501     };
9502
9503     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingFromName",kwnames,&obj0)) goto fail;
9504     {
9505         arg1 = wxString_in_helper(obj0);
9506         if (arg1 == NULL) SWIG_fail;
9507         temp1 = true;
9508     }
9509     {
9510         PyThreadState* __tstate = wxPyBeginAllowThreads();
9511         result = (wxFontEncoding)wxFontMapper::GetEncodingFromName((wxString const &)*arg1);
9512
9513         wxPyEndAllowThreads(__tstate);
9514         if (PyErr_Occurred()) SWIG_fail;
9515     }
9516     resultobj = SWIG_From_int((result));
9517     {
9518         if (temp1)
9519         delete arg1;
9520     }
9521     return resultobj;
9522     fail:
9523     {
9524         if (temp1)
9525         delete arg1;
9526     }
9527     return NULL;
9528 }
9529
9530
9531 static PyObject *_wrap_FontMapper_SetConfig(PyObject *, PyObject *args, PyObject *kwargs) {
9532     PyObject *resultobj;
9533     wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9534     wxConfigBase *arg2 = (wxConfigBase *) 0 ;
9535     PyObject * obj0 = 0 ;
9536     PyObject * obj1 = 0 ;
9537     char *kwnames[] = {
9538         (char *) "self",(char *) "config", NULL
9539     };
9540
9541     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfig",kwnames,&obj0,&obj1)) goto fail;
9542     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9543     if (SWIG_arg_fail(1)) SWIG_fail;
9544     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
9545     if (SWIG_arg_fail(2)) SWIG_fail;
9546     {
9547         PyThreadState* __tstate = wxPyBeginAllowThreads();
9548         (arg1)->SetConfig(arg2);
9549
9550         wxPyEndAllowThreads(__tstate);
9551         if (PyErr_Occurred()) SWIG_fail;
9552     }
9553     Py_INCREF(Py_None); resultobj = Py_None;
9554     return resultobj;
9555     fail:
9556     return NULL;
9557 }
9558
9559
9560 static PyObject *_wrap_FontMapper_SetConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
9561     PyObject *resultobj;
9562     wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9563     wxString *arg2 = 0 ;
9564     bool temp2 = false ;
9565     PyObject * obj0 = 0 ;
9566     PyObject * obj1 = 0 ;
9567     char *kwnames[] = {
9568         (char *) "self",(char *) "prefix", NULL
9569     };
9570
9571     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfigPath",kwnames,&obj0,&obj1)) goto fail;
9572     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9573     if (SWIG_arg_fail(1)) SWIG_fail;
9574     {
9575         arg2 = wxString_in_helper(obj1);
9576         if (arg2 == NULL) SWIG_fail;
9577         temp2 = true;
9578     }
9579     {
9580         PyThreadState* __tstate = wxPyBeginAllowThreads();
9581         (arg1)->SetConfigPath((wxString const &)*arg2);
9582
9583         wxPyEndAllowThreads(__tstate);
9584         if (PyErr_Occurred()) SWIG_fail;
9585     }
9586     Py_INCREF(Py_None); resultobj = Py_None;
9587     {
9588         if (temp2)
9589         delete arg2;
9590     }
9591     return resultobj;
9592     fail:
9593     {
9594         if (temp2)
9595         delete arg2;
9596     }
9597     return NULL;
9598 }
9599
9600
9601 static PyObject *_wrap_FontMapper_GetDefaultConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
9602     PyObject *resultobj;
9603     wxString result;
9604     char *kwnames[] = {
9605         NULL
9606     };
9607
9608     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetDefaultConfigPath",kwnames)) goto fail;
9609     {
9610         PyThreadState* __tstate = wxPyBeginAllowThreads();
9611         result = wxFontMapper::GetDefaultConfigPath();
9612
9613         wxPyEndAllowThreads(__tstate);
9614         if (PyErr_Occurred()) SWIG_fail;
9615     }
9616     {
9617 #if wxUSE_UNICODE
9618         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9619 #else
9620         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9621 #endif
9622     }
9623     return resultobj;
9624     fail:
9625     return NULL;
9626 }
9627
9628
9629 static PyObject *_wrap_FontMapper_GetAltForEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9630     PyObject *resultobj;
9631     wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9632     wxFontEncoding arg2 ;
9633     wxString const &arg3_defvalue = wxPyEmptyString ;
9634     wxString *arg3 = (wxString *) &arg3_defvalue ;
9635     bool arg4 = (bool) true ;
9636     PyObject *result;
9637     bool temp3 = false ;
9638     PyObject * obj0 = 0 ;
9639     PyObject * obj1 = 0 ;
9640     PyObject * obj2 = 0 ;
9641     PyObject * obj3 = 0 ;
9642     char *kwnames[] = {
9643         (char *) "self",(char *) "encoding",(char *) "facename",(char *) "interactive", NULL
9644     };
9645
9646     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:FontMapper_GetAltForEncoding",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9647     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9648     if (SWIG_arg_fail(1)) SWIG_fail;
9649     {
9650         arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9651         if (SWIG_arg_fail(2)) SWIG_fail;
9652     }
9653     if (obj2) {
9654         {
9655             arg3 = wxString_in_helper(obj2);
9656             if (arg3 == NULL) SWIG_fail;
9657             temp3 = true;
9658         }
9659     }
9660     if (obj3) {
9661         {
9662             arg4 = (bool)(SWIG_As_bool(obj3));
9663             if (SWIG_arg_fail(4)) SWIG_fail;
9664         }
9665     }
9666     {
9667         PyThreadState* __tstate = wxPyBeginAllowThreads();
9668         result = (PyObject *)wxFontMapper_GetAltForEncoding(arg1,(wxFontEncoding )arg2,(wxString const &)*arg3,arg4);
9669
9670         wxPyEndAllowThreads(__tstate);
9671         if (PyErr_Occurred()) SWIG_fail;
9672     }
9673     resultobj = result;
9674     {
9675         if (temp3)
9676         delete arg3;
9677     }
9678     return resultobj;
9679     fail:
9680     {
9681         if (temp3)
9682         delete arg3;
9683     }
9684     return NULL;
9685 }
9686
9687
9688 static PyObject *_wrap_FontMapper_IsEncodingAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
9689     PyObject *resultobj;
9690     wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9691     wxFontEncoding arg2 ;
9692     wxString const &arg3_defvalue = wxPyEmptyString ;
9693     wxString *arg3 = (wxString *) &arg3_defvalue ;
9694     bool result;
9695     bool temp3 = false ;
9696     PyObject * obj0 = 0 ;
9697     PyObject * obj1 = 0 ;
9698     PyObject * obj2 = 0 ;
9699     char *kwnames[] = {
9700         (char *) "self",(char *) "encoding",(char *) "facename", NULL
9701     };
9702
9703     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_IsEncodingAvailable",kwnames,&obj0,&obj1,&obj2)) goto fail;
9704     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9705     if (SWIG_arg_fail(1)) SWIG_fail;
9706     {
9707         arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9708         if (SWIG_arg_fail(2)) SWIG_fail;
9709     }
9710     if (obj2) {
9711         {
9712             arg3 = wxString_in_helper(obj2);
9713             if (arg3 == NULL) SWIG_fail;
9714             temp3 = true;
9715         }
9716     }
9717     {
9718         PyThreadState* __tstate = wxPyBeginAllowThreads();
9719         result = (bool)(arg1)->IsEncodingAvailable((wxFontEncoding )arg2,(wxString const &)*arg3);
9720
9721         wxPyEndAllowThreads(__tstate);
9722         if (PyErr_Occurred()) SWIG_fail;
9723     }
9724     {
9725         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9726     }
9727     {
9728         if (temp3)
9729         delete arg3;
9730     }
9731     return resultobj;
9732     fail:
9733     {
9734         if (temp3)
9735         delete arg3;
9736     }
9737     return NULL;
9738 }
9739
9740
9741 static PyObject *_wrap_FontMapper_SetDialogParent(PyObject *, PyObject *args, PyObject *kwargs) {
9742     PyObject *resultobj;
9743     wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9744     wxWindow *arg2 = (wxWindow *) 0 ;
9745     PyObject * obj0 = 0 ;
9746     PyObject * obj1 = 0 ;
9747     char *kwnames[] = {
9748         (char *) "self",(char *) "parent", NULL
9749     };
9750
9751     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogParent",kwnames,&obj0,&obj1)) goto fail;
9752     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9753     if (SWIG_arg_fail(1)) SWIG_fail;
9754     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9755     if (SWIG_arg_fail(2)) SWIG_fail;
9756     {
9757         PyThreadState* __tstate = wxPyBeginAllowThreads();
9758         (arg1)->SetDialogParent(arg2);
9759
9760         wxPyEndAllowThreads(__tstate);
9761         if (PyErr_Occurred()) SWIG_fail;
9762     }
9763     Py_INCREF(Py_None); resultobj = Py_None;
9764     return resultobj;
9765     fail:
9766     return NULL;
9767 }
9768
9769
9770 static PyObject *_wrap_FontMapper_SetDialogTitle(PyObject *, PyObject *args, PyObject *kwargs) {
9771     PyObject *resultobj;
9772     wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9773     wxString *arg2 = 0 ;
9774     bool temp2 = false ;
9775     PyObject * obj0 = 0 ;
9776     PyObject * obj1 = 0 ;
9777     char *kwnames[] = {
9778         (char *) "self",(char *) "title", NULL
9779     };
9780
9781     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogTitle",kwnames,&obj0,&obj1)) goto fail;
9782     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9783     if (SWIG_arg_fail(1)) SWIG_fail;
9784     {
9785         arg2 = wxString_in_helper(obj1);
9786         if (arg2 == NULL) SWIG_fail;
9787         temp2 = true;
9788     }
9789     {
9790         PyThreadState* __tstate = wxPyBeginAllowThreads();
9791         (arg1)->SetDialogTitle((wxString const &)*arg2);
9792
9793         wxPyEndAllowThreads(__tstate);
9794         if (PyErr_Occurred()) SWIG_fail;
9795     }
9796     Py_INCREF(Py_None); resultobj = Py_None;
9797     {
9798         if (temp2)
9799         delete arg2;
9800     }
9801     return resultobj;
9802     fail:
9803     {
9804         if (temp2)
9805         delete arg2;
9806     }
9807     return NULL;
9808 }
9809
9810
9811 static PyObject * FontMapper_swigregister(PyObject *, PyObject *args) {
9812     PyObject *obj;
9813     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9814     SWIG_TypeClientData(SWIGTYPE_p_wxFontMapper, obj);
9815     Py_INCREF(obj);
9816     return Py_BuildValue((char *)"");
9817 }
9818 static PyObject *_wrap_new_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9819     PyObject *resultobj;
9820     int arg1 ;
9821     int arg2 ;
9822     int arg3 ;
9823     int arg4 ;
9824     bool arg5 = (bool) false ;
9825     wxString const &arg6_defvalue = wxPyEmptyString ;
9826     wxString *arg6 = (wxString *) &arg6_defvalue ;
9827     wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9828     wxFont *result;
9829     bool temp6 = false ;
9830     PyObject * obj0 = 0 ;
9831     PyObject * obj1 = 0 ;
9832     PyObject * obj2 = 0 ;
9833     PyObject * obj3 = 0 ;
9834     PyObject * obj4 = 0 ;
9835     PyObject * obj5 = 0 ;
9836     PyObject * obj6 = 0 ;
9837     char *kwnames[] = {
9838         (char *) "pointSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "face",(char *) "encoding", NULL
9839     };
9840
9841     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_Font",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9842     {
9843         arg1 = (int)(SWIG_As_int(obj0));
9844         if (SWIG_arg_fail(1)) SWIG_fail;
9845     }
9846     {
9847         arg2 = (int)(SWIG_As_int(obj1));
9848         if (SWIG_arg_fail(2)) SWIG_fail;
9849     }
9850     {
9851         arg3 = (int)(SWIG_As_int(obj2));
9852         if (SWIG_arg_fail(3)) SWIG_fail;
9853     }
9854     {
9855         arg4 = (int)(SWIG_As_int(obj3));
9856         if (SWIG_arg_fail(4)) SWIG_fail;
9857     }
9858     if (obj4) {
9859         {
9860             arg5 = (bool)(SWIG_As_bool(obj4));
9861             if (SWIG_arg_fail(5)) SWIG_fail;
9862         }
9863     }
9864     if (obj5) {
9865         {
9866             arg6 = wxString_in_helper(obj5);
9867             if (arg6 == NULL) SWIG_fail;
9868             temp6 = true;
9869         }
9870     }
9871     if (obj6) {
9872         {
9873             arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9874             if (SWIG_arg_fail(7)) SWIG_fail;
9875         }
9876     }
9877     {
9878         if (!wxPyCheckForApp()) SWIG_fail;
9879         PyThreadState* __tstate = wxPyBeginAllowThreads();
9880         result = (wxFont *)new wxFont(arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9881
9882         wxPyEndAllowThreads(__tstate);
9883         if (PyErr_Occurred()) SWIG_fail;
9884     }
9885     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9886     {
9887         if (temp6)
9888         delete arg6;
9889     }
9890     return resultobj;
9891     fail:
9892     {
9893         if (temp6)
9894         delete arg6;
9895     }
9896     return NULL;
9897 }
9898
9899
9900 static PyObject *_wrap_delete_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9901     PyObject *resultobj;
9902     wxFont *arg1 = (wxFont *) 0 ;
9903     PyObject * obj0 = 0 ;
9904     char *kwnames[] = {
9905         (char *) "self", NULL
9906     };
9907
9908     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Font",kwnames,&obj0)) goto fail;
9909     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9910     if (SWIG_arg_fail(1)) SWIG_fail;
9911     {
9912         PyThreadState* __tstate = wxPyBeginAllowThreads();
9913         delete arg1;
9914
9915         wxPyEndAllowThreads(__tstate);
9916         if (PyErr_Occurred()) SWIG_fail;
9917     }
9918     Py_INCREF(Py_None); resultobj = Py_None;
9919     return resultobj;
9920     fail:
9921     return NULL;
9922 }
9923
9924
9925 static PyObject *_wrap_new_FontFromNativeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9926     PyObject *resultobj;
9927     wxNativeFontInfo *arg1 = 0 ;
9928     wxFont *result;
9929     PyObject * obj0 = 0 ;
9930     char *kwnames[] = {
9931         (char *) "info", NULL
9932     };
9933
9934     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfo",kwnames,&obj0)) goto fail;
9935     {
9936         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
9937         if (SWIG_arg_fail(1)) SWIG_fail;
9938         if (arg1 == NULL) {
9939             SWIG_null_ref("wxNativeFontInfo");
9940         }
9941         if (SWIG_arg_fail(1)) SWIG_fail;
9942     }
9943     {
9944         if (!wxPyCheckForApp()) SWIG_fail;
9945         PyThreadState* __tstate = wxPyBeginAllowThreads();
9946         result = (wxFont *)new wxFont((wxNativeFontInfo const &)*arg1);
9947
9948         wxPyEndAllowThreads(__tstate);
9949         if (PyErr_Occurred()) SWIG_fail;
9950     }
9951     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9952     return resultobj;
9953     fail:
9954     return NULL;
9955 }
9956
9957
9958 static PyObject *_wrap_new_FontFromNativeInfoString(PyObject *, PyObject *args, PyObject *kwargs) {
9959     PyObject *resultobj;
9960     wxString *arg1 = 0 ;
9961     wxFont *result;
9962     bool temp1 = false ;
9963     PyObject * obj0 = 0 ;
9964     char *kwnames[] = {
9965         (char *) "info", NULL
9966     };
9967
9968     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfoString",kwnames,&obj0)) goto fail;
9969     {
9970         arg1 = wxString_in_helper(obj0);
9971         if (arg1 == NULL) SWIG_fail;
9972         temp1 = true;
9973     }
9974     {
9975         if (!wxPyCheckForApp()) SWIG_fail;
9976         PyThreadState* __tstate = wxPyBeginAllowThreads();
9977         result = (wxFont *)new_wxFont((wxString const &)*arg1);
9978
9979         wxPyEndAllowThreads(__tstate);
9980         if (PyErr_Occurred()) SWIG_fail;
9981     }
9982     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9983     {
9984         if (temp1)
9985         delete arg1;
9986     }
9987     return resultobj;
9988     fail:
9989     {
9990         if (temp1)
9991         delete arg1;
9992     }
9993     return NULL;
9994 }
9995
9996
9997 static PyObject *_wrap_new_Font2(PyObject *, PyObject *args, PyObject *kwargs) {
9998     PyObject *resultobj;
9999     int arg1 ;
10000     wxFontFamily arg2 ;
10001     int arg3 = (int) wxFONTFLAG_DEFAULT ;
10002     wxString const &arg4_defvalue = wxPyEmptyString ;
10003     wxString *arg4 = (wxString *) &arg4_defvalue ;
10004     wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
10005     wxFont *result;
10006     bool temp4 = false ;
10007     PyObject * obj0 = 0 ;
10008     PyObject * obj1 = 0 ;
10009     PyObject * obj2 = 0 ;
10010     PyObject * obj3 = 0 ;
10011     PyObject * obj4 = 0 ;
10012     char *kwnames[] = {
10013         (char *) "pointSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
10014     };
10015
10016     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_Font2",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
10017     {
10018         arg1 = (int)(SWIG_As_int(obj0));
10019         if (SWIG_arg_fail(1)) SWIG_fail;
10020     }
10021     {
10022         arg2 = (wxFontFamily)(SWIG_As_int(obj1));
10023         if (SWIG_arg_fail(2)) SWIG_fail;
10024     }
10025     if (obj2) {
10026         {
10027             arg3 = (int)(SWIG_As_int(obj2));
10028             if (SWIG_arg_fail(3)) SWIG_fail;
10029         }
10030     }
10031     if (obj3) {
10032         {
10033             arg4 = wxString_in_helper(obj3);
10034             if (arg4 == NULL) SWIG_fail;
10035             temp4 = true;
10036         }
10037     }
10038     if (obj4) {
10039         {
10040             arg5 = (wxFontEncoding)(SWIG_As_int(obj4));
10041             if (SWIG_arg_fail(5)) SWIG_fail;
10042         }
10043     }
10044     {
10045         if (!wxPyCheckForApp()) SWIG_fail;
10046         PyThreadState* __tstate = wxPyBeginAllowThreads();
10047         result = (wxFont *)new_wxFont(arg1,(wxFontFamily )arg2,arg3,(wxString const &)*arg4,(wxFontEncoding )arg5);
10048
10049         wxPyEndAllowThreads(__tstate);
10050         if (PyErr_Occurred()) SWIG_fail;
10051     }
10052     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
10053     {
10054         if (temp4)
10055         delete arg4;
10056     }
10057     return resultobj;
10058     fail:
10059     {
10060         if (temp4)
10061         delete arg4;
10062     }
10063     return NULL;
10064 }
10065
10066
10067 static PyObject *_wrap_new_FontFromPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10068     PyObject *resultobj;
10069     wxSize *arg1 = 0 ;
10070     int arg2 ;
10071     int arg3 ;
10072     int arg4 ;
10073     bool arg5 = (bool) false ;
10074     wxString const &arg6_defvalue = wxEmptyString ;
10075     wxString *arg6 = (wxString *) &arg6_defvalue ;
10076     wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
10077     wxFont *result;
10078     wxSize temp1 ;
10079     bool temp6 = false ;
10080     PyObject * obj0 = 0 ;
10081     PyObject * obj1 = 0 ;
10082     PyObject * obj2 = 0 ;
10083     PyObject * obj3 = 0 ;
10084     PyObject * obj4 = 0 ;
10085     PyObject * obj5 = 0 ;
10086     PyObject * obj6 = 0 ;
10087     char *kwnames[] = {
10088         (char *) "pixelSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underlined",(char *) "face",(char *) "encoding", NULL
10089     };
10090
10091     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_FontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
10092     {
10093         arg1 = &temp1;
10094         if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
10095     }
10096     {
10097         arg2 = (int)(SWIG_As_int(obj1));
10098         if (SWIG_arg_fail(2)) SWIG_fail;
10099     }
10100     {
10101         arg3 = (int)(SWIG_As_int(obj2));
10102         if (SWIG_arg_fail(3)) SWIG_fail;
10103     }
10104     {
10105         arg4 = (int)(SWIG_As_int(obj3));
10106         if (SWIG_arg_fail(4)) SWIG_fail;
10107     }
10108     if (obj4) {
10109         {
10110             arg5 = (bool)(SWIG_As_bool(obj4));
10111             if (SWIG_arg_fail(5)) SWIG_fail;
10112         }
10113     }
10114     if (obj5) {
10115         {
10116             arg6 = wxString_in_helper(obj5);
10117             if (arg6 == NULL) SWIG_fail;
10118             temp6 = true;
10119         }
10120     }
10121     if (obj6) {
10122         {
10123             arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
10124             if (SWIG_arg_fail(7)) SWIG_fail;
10125         }
10126     }
10127     {
10128         if (!wxPyCheckForApp()) SWIG_fail;
10129         PyThreadState* __tstate = wxPyBeginAllowThreads();
10130         result = (wxFont *)new_wxFont((wxSize const &)*arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
10131
10132         wxPyEndAllowThreads(__tstate);
10133         if (PyErr_Occurred()) SWIG_fail;
10134     }
10135     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
10136     {
10137         if (temp6)
10138         delete arg6;
10139     }
10140     return resultobj;
10141     fail:
10142     {
10143         if (temp6)
10144         delete arg6;
10145     }
10146     return NULL;
10147 }
10148
10149
10150 static PyObject *_wrap_Font_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
10151     PyObject *resultobj;
10152     wxFont *arg1 = (wxFont *) 0 ;
10153     bool result;
10154     PyObject * obj0 = 0 ;
10155     char *kwnames[] = {
10156         (char *) "self", NULL
10157     };
10158
10159     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_Ok",kwnames,&obj0)) goto fail;
10160     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10161     if (SWIG_arg_fail(1)) SWIG_fail;
10162     {
10163         PyThreadState* __tstate = wxPyBeginAllowThreads();
10164         result = (bool)((wxFont const *)arg1)->Ok();
10165
10166         wxPyEndAllowThreads(__tstate);
10167         if (PyErr_Occurred()) SWIG_fail;
10168     }
10169     {
10170         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10171     }
10172     return resultobj;
10173     fail:
10174     return NULL;
10175 }
10176
10177
10178 static PyObject *_wrap_Font___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
10179     PyObject *resultobj;
10180     wxFont *arg1 = (wxFont *) 0 ;
10181     wxFont *arg2 = (wxFont *) 0 ;
10182     bool result;
10183     PyObject * obj0 = 0 ;
10184     PyObject * obj1 = 0 ;
10185     char *kwnames[] = {
10186         (char *) "self",(char *) "other", NULL
10187     };
10188
10189     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___eq__",kwnames,&obj0,&obj1)) goto fail;
10190     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10191     if (SWIG_arg_fail(1)) SWIG_fail;
10192     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10193     if (SWIG_arg_fail(2)) SWIG_fail;
10194     {
10195         PyThreadState* __tstate = wxPyBeginAllowThreads();
10196         result = (bool)wxFont___eq__(arg1,(wxFont const *)arg2);
10197
10198         wxPyEndAllowThreads(__tstate);
10199         if (PyErr_Occurred()) SWIG_fail;
10200     }
10201     {
10202         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10203     }
10204     return resultobj;
10205     fail:
10206     return NULL;
10207 }
10208
10209
10210 static PyObject *_wrap_Font___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
10211     PyObject *resultobj;
10212     wxFont *arg1 = (wxFont *) 0 ;
10213     wxFont *arg2 = (wxFont *) 0 ;
10214     bool result;
10215     PyObject * obj0 = 0 ;
10216     PyObject * obj1 = 0 ;
10217     char *kwnames[] = {
10218         (char *) "self",(char *) "other", NULL
10219     };
10220
10221     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___ne__",kwnames,&obj0,&obj1)) goto fail;
10222     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10223     if (SWIG_arg_fail(1)) SWIG_fail;
10224     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10225     if (SWIG_arg_fail(2)) SWIG_fail;
10226     {
10227         PyThreadState* __tstate = wxPyBeginAllowThreads();
10228         result = (bool)wxFont___ne__(arg1,(wxFont const *)arg2);
10229
10230         wxPyEndAllowThreads(__tstate);
10231         if (PyErr_Occurred()) SWIG_fail;
10232     }
10233     {
10234         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10235     }
10236     return resultobj;
10237     fail:
10238     return NULL;
10239 }
10240
10241
10242 static PyObject *_wrap_Font_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
10243     PyObject *resultobj;
10244     wxFont *arg1 = (wxFont *) 0 ;
10245     int result;
10246     PyObject * obj0 = 0 ;
10247     char *kwnames[] = {
10248         (char *) "self", NULL
10249     };
10250
10251     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPointSize",kwnames,&obj0)) goto fail;
10252     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10253     if (SWIG_arg_fail(1)) SWIG_fail;
10254     {
10255         PyThreadState* __tstate = wxPyBeginAllowThreads();
10256         result = (int)((wxFont const *)arg1)->GetPointSize();
10257
10258         wxPyEndAllowThreads(__tstate);
10259         if (PyErr_Occurred()) SWIG_fail;
10260     }
10261     {
10262         resultobj = SWIG_From_int((int)(result));
10263     }
10264     return resultobj;
10265     fail:
10266     return NULL;
10267 }
10268
10269
10270 static PyObject *_wrap_Font_GetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10271     PyObject *resultobj;
10272     wxFont *arg1 = (wxFont *) 0 ;
10273     wxSize result;
10274     PyObject * obj0 = 0 ;
10275     char *kwnames[] = {
10276         (char *) "self", NULL
10277     };
10278
10279     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPixelSize",kwnames,&obj0)) goto fail;
10280     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10281     if (SWIG_arg_fail(1)) SWIG_fail;
10282     {
10283         PyThreadState* __tstate = wxPyBeginAllowThreads();
10284         result = ((wxFont const *)arg1)->GetPixelSize();
10285
10286         wxPyEndAllowThreads(__tstate);
10287         if (PyErr_Occurred()) SWIG_fail;
10288     }
10289     {
10290         wxSize * resultptr;
10291         resultptr = new wxSize((wxSize &)(result));
10292         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
10293     }
10294     return resultobj;
10295     fail:
10296     return NULL;
10297 }
10298
10299
10300 static PyObject *_wrap_Font_IsUsingSizeInPixels(PyObject *, PyObject *args, PyObject *kwargs) {
10301     PyObject *resultobj;
10302     wxFont *arg1 = (wxFont *) 0 ;
10303     bool result;
10304     PyObject * obj0 = 0 ;
10305     char *kwnames[] = {
10306         (char *) "self", NULL
10307     };
10308
10309     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsUsingSizeInPixels",kwnames,&obj0)) goto fail;
10310     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10311     if (SWIG_arg_fail(1)) SWIG_fail;
10312     {
10313         PyThreadState* __tstate = wxPyBeginAllowThreads();
10314         result = (bool)((wxFont const *)arg1)->IsUsingSizeInPixels();
10315
10316         wxPyEndAllowThreads(__tstate);
10317         if (PyErr_Occurred()) SWIG_fail;
10318     }
10319     {
10320         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10321     }
10322     return resultobj;
10323     fail:
10324     return NULL;
10325 }
10326
10327
10328 static PyObject *_wrap_Font_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
10329     PyObject *resultobj;
10330     wxFont *arg1 = (wxFont *) 0 ;
10331     int result;
10332     PyObject * obj0 = 0 ;
10333     char *kwnames[] = {
10334         (char *) "self", NULL
10335     };
10336
10337     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamily",kwnames,&obj0)) goto fail;
10338     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10339     if (SWIG_arg_fail(1)) SWIG_fail;
10340     {
10341         PyThreadState* __tstate = wxPyBeginAllowThreads();
10342         result = (int)((wxFont const *)arg1)->GetFamily();
10343
10344         wxPyEndAllowThreads(__tstate);
10345         if (PyErr_Occurred()) SWIG_fail;
10346     }
10347     {
10348         resultobj = SWIG_From_int((int)(result));
10349     }
10350     return resultobj;
10351     fail:
10352     return NULL;
10353 }
10354
10355
10356 static PyObject *_wrap_Font_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10357     PyObject *resultobj;
10358     wxFont *arg1 = (wxFont *) 0 ;
10359     int result;
10360     PyObject * obj0 = 0 ;
10361     char *kwnames[] = {
10362         (char *) "self", NULL
10363     };
10364
10365     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyle",kwnames,&obj0)) goto fail;
10366     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10367     if (SWIG_arg_fail(1)) SWIG_fail;
10368     {
10369         PyThreadState* __tstate = wxPyBeginAllowThreads();
10370         result = (int)((wxFont const *)arg1)->GetStyle();
10371
10372         wxPyEndAllowThreads(__tstate);
10373         if (PyErr_Occurred()) SWIG_fail;
10374     }
10375     {
10376         resultobj = SWIG_From_int((int)(result));
10377     }
10378     return resultobj;
10379     fail:
10380     return NULL;
10381 }
10382
10383
10384 static PyObject *_wrap_Font_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
10385     PyObject *resultobj;
10386     wxFont *arg1 = (wxFont *) 0 ;
10387     int result;
10388     PyObject * obj0 = 0 ;
10389     char *kwnames[] = {
10390         (char *) "self", NULL
10391     };
10392
10393     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeight",kwnames,&obj0)) goto fail;
10394     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10395     if (SWIG_arg_fail(1)) SWIG_fail;
10396     {
10397         PyThreadState* __tstate = wxPyBeginAllowThreads();
10398         result = (int)((wxFont const *)arg1)->GetWeight();
10399
10400         wxPyEndAllowThreads(__tstate);
10401         if (PyErr_Occurred()) SWIG_fail;
10402     }
10403     {
10404         resultobj = SWIG_From_int((int)(result));
10405     }
10406     return resultobj;
10407     fail:
10408     return NULL;
10409 }
10410
10411
10412 static PyObject *_wrap_Font_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
10413     PyObject *resultobj;
10414     wxFont *arg1 = (wxFont *) 0 ;
10415     bool result;
10416     PyObject * obj0 = 0 ;
10417     char *kwnames[] = {
10418         (char *) "self", NULL
10419     };
10420
10421     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetUnderlined",kwnames,&obj0)) goto fail;
10422     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10423     if (SWIG_arg_fail(1)) SWIG_fail;
10424     {
10425         PyThreadState* __tstate = wxPyBeginAllowThreads();
10426         result = (bool)((wxFont const *)arg1)->GetUnderlined();
10427
10428         wxPyEndAllowThreads(__tstate);
10429         if (PyErr_Occurred()) SWIG_fail;
10430     }
10431     {
10432         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10433     }
10434     return resultobj;
10435     fail:
10436     return NULL;
10437 }
10438
10439
10440 static PyObject *_wrap_Font_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
10441     PyObject *resultobj;
10442     wxFont *arg1 = (wxFont *) 0 ;
10443     wxString result;
10444     PyObject * obj0 = 0 ;
10445     char *kwnames[] = {
10446         (char *) "self", NULL
10447     };
10448
10449     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFaceName",kwnames,&obj0)) goto fail;
10450     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10451     if (SWIG_arg_fail(1)) SWIG_fail;
10452     {
10453         PyThreadState* __tstate = wxPyBeginAllowThreads();
10454         result = ((wxFont const *)arg1)->GetFaceName();
10455
10456         wxPyEndAllowThreads(__tstate);
10457         if (PyErr_Occurred()) SWIG_fail;
10458     }
10459     {
10460 #if wxUSE_UNICODE
10461         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10462 #else
10463         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10464 #endif
10465     }
10466     return resultobj;
10467     fail:
10468     return NULL;
10469 }
10470
10471
10472 static PyObject *_wrap_Font_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10473     PyObject *resultobj;
10474     wxFont *arg1 = (wxFont *) 0 ;
10475     wxFontEncoding result;
10476     PyObject * obj0 = 0 ;
10477     char *kwnames[] = {
10478         (char *) "self", NULL
10479     };
10480
10481     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetEncoding",kwnames,&obj0)) goto fail;
10482     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10483     if (SWIG_arg_fail(1)) SWIG_fail;
10484     {
10485         PyThreadState* __tstate = wxPyBeginAllowThreads();
10486         result = (wxFontEncoding)((wxFont const *)arg1)->GetEncoding();
10487
10488         wxPyEndAllowThreads(__tstate);
10489         if (PyErr_Occurred()) SWIG_fail;
10490     }
10491     resultobj = SWIG_From_int((result));
10492     return resultobj;
10493     fail:
10494     return NULL;
10495 }
10496
10497
10498 static PyObject *_wrap_Font_GetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10499     PyObject *resultobj;
10500     wxFont *arg1 = (wxFont *) 0 ;
10501     wxNativeFontInfo *result;
10502     PyObject * obj0 = 0 ;
10503     char *kwnames[] = {
10504         (char *) "self", NULL
10505     };
10506
10507     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfo",kwnames,&obj0)) goto fail;
10508     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10509     if (SWIG_arg_fail(1)) SWIG_fail;
10510     {
10511         PyThreadState* __tstate = wxPyBeginAllowThreads();
10512         result = (wxNativeFontInfo *)((wxFont const *)arg1)->GetNativeFontInfo();
10513
10514         wxPyEndAllowThreads(__tstate);
10515         if (PyErr_Occurred()) SWIG_fail;
10516     }
10517     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 0);
10518     return resultobj;
10519     fail:
10520     return NULL;
10521 }
10522
10523
10524 static PyObject *_wrap_Font_IsFixedWidth(PyObject *, PyObject *args, PyObject *kwargs) {
10525     PyObject *resultobj;
10526     wxFont *arg1 = (wxFont *) 0 ;
10527     bool result;
10528     PyObject * obj0 = 0 ;
10529     char *kwnames[] = {
10530         (char *) "self", NULL
10531     };
10532
10533     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsFixedWidth",kwnames,&obj0)) goto fail;
10534     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10535     if (SWIG_arg_fail(1)) SWIG_fail;
10536     {
10537         PyThreadState* __tstate = wxPyBeginAllowThreads();
10538         result = (bool)((wxFont const *)arg1)->IsFixedWidth();
10539
10540         wxPyEndAllowThreads(__tstate);
10541         if (PyErr_Occurred()) SWIG_fail;
10542     }
10543     {
10544         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10545     }
10546     return resultobj;
10547     fail:
10548     return NULL;
10549 }
10550
10551
10552 static PyObject *_wrap_Font_GetNativeFontInfoDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10553     PyObject *resultobj;
10554     wxFont *arg1 = (wxFont *) 0 ;
10555     wxString result;
10556     PyObject * obj0 = 0 ;
10557     char *kwnames[] = {
10558         (char *) "self", NULL
10559     };
10560
10561     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoDesc",kwnames,&obj0)) goto fail;
10562     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10563     if (SWIG_arg_fail(1)) SWIG_fail;
10564     {
10565         PyThreadState* __tstate = wxPyBeginAllowThreads();
10566         result = ((wxFont const *)arg1)->GetNativeFontInfoDesc();
10567
10568         wxPyEndAllowThreads(__tstate);
10569         if (PyErr_Occurred()) SWIG_fail;
10570     }
10571     {
10572 #if wxUSE_UNICODE
10573         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10574 #else
10575         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10576 #endif
10577     }
10578     return resultobj;
10579     fail:
10580     return NULL;
10581 }
10582
10583
10584 static PyObject *_wrap_Font_GetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10585     PyObject *resultobj;
10586     wxFont *arg1 = (wxFont *) 0 ;
10587     wxString result;
10588     PyObject * obj0 = 0 ;
10589     char *kwnames[] = {
10590         (char *) "self", NULL
10591     };
10592
10593     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoUserDesc",kwnames,&obj0)) goto fail;
10594     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10595     if (SWIG_arg_fail(1)) SWIG_fail;
10596     {
10597         PyThreadState* __tstate = wxPyBeginAllowThreads();
10598         result = ((wxFont const *)arg1)->GetNativeFontInfoUserDesc();
10599
10600         wxPyEndAllowThreads(__tstate);
10601         if (PyErr_Occurred()) SWIG_fail;
10602     }
10603     {
10604 #if wxUSE_UNICODE
10605         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10606 #else
10607         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10608 #endif
10609     }
10610     return resultobj;
10611     fail:
10612     return NULL;
10613 }
10614
10615
10616 static PyObject *_wrap_Font_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
10617     PyObject *resultobj;
10618     wxFont *arg1 = (wxFont *) 0 ;
10619     int arg2 ;
10620     PyObject * obj0 = 0 ;
10621     PyObject * obj1 = 0 ;
10622     char *kwnames[] = {
10623         (char *) "self",(char *) "pointSize", NULL
10624     };
10625
10626     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
10627     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10628     if (SWIG_arg_fail(1)) SWIG_fail;
10629     {
10630         arg2 = (int)(SWIG_As_int(obj1));
10631         if (SWIG_arg_fail(2)) SWIG_fail;
10632     }
10633     {
10634         PyThreadState* __tstate = wxPyBeginAllowThreads();
10635         (arg1)->SetPointSize(arg2);
10636
10637         wxPyEndAllowThreads(__tstate);
10638         if (PyErr_Occurred()) SWIG_fail;
10639     }
10640     Py_INCREF(Py_None); resultobj = Py_None;
10641     return resultobj;
10642     fail:
10643     return NULL;
10644 }
10645
10646
10647 static PyObject *_wrap_Font_SetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10648     PyObject *resultobj;
10649     wxFont *arg1 = (wxFont *) 0 ;
10650     wxSize *arg2 = 0 ;
10651     wxSize temp2 ;
10652     PyObject * obj0 = 0 ;
10653     PyObject * obj1 = 0 ;
10654     char *kwnames[] = {
10655         (char *) "self",(char *) "pixelSize", NULL
10656     };
10657
10658     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPixelSize",kwnames,&obj0,&obj1)) goto fail;
10659     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10660     if (SWIG_arg_fail(1)) SWIG_fail;
10661     {
10662         arg2 = &temp2;
10663         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
10664     }
10665     {
10666         PyThreadState* __tstate = wxPyBeginAllowThreads();
10667         (arg1)->SetPixelSize((wxSize const &)*arg2);
10668
10669         wxPyEndAllowThreads(__tstate);
10670         if (PyErr_Occurred()) SWIG_fail;
10671     }
10672     Py_INCREF(Py_None); resultobj = Py_None;
10673     return resultobj;
10674     fail:
10675     return NULL;
10676 }
10677
10678
10679 static PyObject *_wrap_Font_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
10680     PyObject *resultobj;
10681     wxFont *arg1 = (wxFont *) 0 ;
10682     int arg2 ;
10683     PyObject * obj0 = 0 ;
10684     PyObject * obj1 = 0 ;
10685     char *kwnames[] = {
10686         (char *) "self",(char *) "family", NULL
10687     };
10688
10689     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFamily",kwnames,&obj0,&obj1)) goto fail;
10690     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10691     if (SWIG_arg_fail(1)) SWIG_fail;
10692     {
10693         arg2 = (int)(SWIG_As_int(obj1));
10694         if (SWIG_arg_fail(2)) SWIG_fail;
10695     }
10696     {
10697         PyThreadState* __tstate = wxPyBeginAllowThreads();
10698         (arg1)->SetFamily(arg2);
10699
10700         wxPyEndAllowThreads(__tstate);
10701         if (PyErr_Occurred()) SWIG_fail;
10702     }
10703     Py_INCREF(Py_None); resultobj = Py_None;
10704     return resultobj;
10705     fail:
10706     return NULL;
10707 }
10708
10709
10710 static PyObject *_wrap_Font_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10711     PyObject *resultobj;
10712     wxFont *arg1 = (wxFont *) 0 ;
10713     int arg2 ;
10714     PyObject * obj0 = 0 ;
10715     PyObject * obj1 = 0 ;
10716     char *kwnames[] = {
10717         (char *) "self",(char *) "style", NULL
10718     };
10719
10720     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetStyle",kwnames,&obj0,&obj1)) goto fail;
10721     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10722     if (SWIG_arg_fail(1)) SWIG_fail;
10723     {
10724         arg2 = (int)(SWIG_As_int(obj1));
10725         if (SWIG_arg_fail(2)) SWIG_fail;
10726     }
10727     {
10728         PyThreadState* __tstate = wxPyBeginAllowThreads();
10729         (arg1)->SetStyle(arg2);
10730
10731         wxPyEndAllowThreads(__tstate);
10732         if (PyErr_Occurred()) SWIG_fail;
10733     }
10734     Py_INCREF(Py_None); resultobj = Py_None;
10735     return resultobj;
10736     fail:
10737     return NULL;
10738 }
10739
10740
10741 static PyObject *_wrap_Font_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
10742     PyObject *resultobj;
10743     wxFont *arg1 = (wxFont *) 0 ;
10744     int arg2 ;
10745     PyObject * obj0 = 0 ;
10746     PyObject * obj1 = 0 ;
10747     char *kwnames[] = {
10748         (char *) "self",(char *) "weight", NULL
10749     };
10750
10751     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetWeight",kwnames,&obj0,&obj1)) goto fail;
10752     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10753     if (SWIG_arg_fail(1)) SWIG_fail;
10754     {
10755         arg2 = (int)(SWIG_As_int(obj1));
10756         if (SWIG_arg_fail(2)) SWIG_fail;
10757     }
10758     {
10759         PyThreadState* __tstate = wxPyBeginAllowThreads();
10760         (arg1)->SetWeight(arg2);
10761
10762         wxPyEndAllowThreads(__tstate);
10763         if (PyErr_Occurred()) SWIG_fail;
10764     }
10765     Py_INCREF(Py_None); resultobj = Py_None;
10766     return resultobj;
10767     fail:
10768     return NULL;
10769 }
10770
10771
10772 static PyObject *_wrap_Font_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
10773     PyObject *resultobj;
10774     wxFont *arg1 = (wxFont *) 0 ;
10775     wxString *arg2 = 0 ;
10776     bool temp2 = false ;
10777     PyObject * obj0 = 0 ;
10778     PyObject * obj1 = 0 ;
10779     char *kwnames[] = {
10780         (char *) "self",(char *) "faceName", NULL
10781     };
10782
10783     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
10784     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10785     if (SWIG_arg_fail(1)) SWIG_fail;
10786     {
10787         arg2 = wxString_in_helper(obj1);
10788         if (arg2 == NULL) SWIG_fail;
10789         temp2 = true;
10790     }
10791     {
10792         PyThreadState* __tstate = wxPyBeginAllowThreads();
10793         (arg1)->SetFaceName((wxString const &)*arg2);
10794
10795         wxPyEndAllowThreads(__tstate);
10796         if (PyErr_Occurred()) SWIG_fail;
10797     }
10798     Py_INCREF(Py_None); resultobj = Py_None;
10799     {
10800         if (temp2)
10801         delete arg2;
10802     }
10803     return resultobj;
10804     fail:
10805     {
10806         if (temp2)
10807         delete arg2;
10808     }
10809     return NULL;
10810 }
10811
10812
10813 static PyObject *_wrap_Font_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
10814     PyObject *resultobj;
10815     wxFont *arg1 = (wxFont *) 0 ;
10816     bool arg2 ;
10817     PyObject * obj0 = 0 ;
10818     PyObject * obj1 = 0 ;
10819     char *kwnames[] = {
10820         (char *) "self",(char *) "underlined", NULL
10821     };
10822
10823     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
10824     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10825     if (SWIG_arg_fail(1)) SWIG_fail;
10826     {
10827         arg2 = (bool)(SWIG_As_bool(obj1));
10828         if (SWIG_arg_fail(2)) SWIG_fail;
10829     }
10830     {
10831         PyThreadState* __tstate = wxPyBeginAllowThreads();
10832         (arg1)->SetUnderlined(arg2);
10833
10834         wxPyEndAllowThreads(__tstate);
10835         if (PyErr_Occurred()) SWIG_fail;
10836     }
10837     Py_INCREF(Py_None); resultobj = Py_None;
10838     return resultobj;
10839     fail:
10840     return NULL;
10841 }
10842
10843
10844 static PyObject *_wrap_Font_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10845     PyObject *resultobj;
10846     wxFont *arg1 = (wxFont *) 0 ;
10847     wxFontEncoding arg2 ;
10848     PyObject * obj0 = 0 ;
10849     PyObject * obj1 = 0 ;
10850     char *kwnames[] = {
10851         (char *) "self",(char *) "encoding", NULL
10852     };
10853
10854     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
10855     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10856     if (SWIG_arg_fail(1)) SWIG_fail;
10857     {
10858         arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10859         if (SWIG_arg_fail(2)) SWIG_fail;
10860     }
10861     {
10862         PyThreadState* __tstate = wxPyBeginAllowThreads();
10863         (arg1)->SetEncoding((wxFontEncoding )arg2);
10864
10865         wxPyEndAllowThreads(__tstate);
10866         if (PyErr_Occurred()) SWIG_fail;
10867     }
10868     Py_INCREF(Py_None); resultobj = Py_None;
10869     return resultobj;
10870     fail:
10871     return NULL;
10872 }
10873
10874
10875 static PyObject *_wrap_Font_SetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10876     PyObject *resultobj;
10877     wxFont *arg1 = (wxFont *) 0 ;
10878     wxNativeFontInfo *arg2 = 0 ;
10879     PyObject * obj0 = 0 ;
10880     PyObject * obj1 = 0 ;
10881     char *kwnames[] = {
10882         (char *) "self",(char *) "info", NULL
10883     };
10884
10885     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfo",kwnames,&obj0,&obj1)) goto fail;
10886     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10887     if (SWIG_arg_fail(1)) SWIG_fail;
10888     {
10889         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
10890         if (SWIG_arg_fail(2)) SWIG_fail;
10891         if (arg2 == NULL) {
10892             SWIG_null_ref("wxNativeFontInfo");
10893         }
10894         if (SWIG_arg_fail(2)) SWIG_fail;
10895     }
10896     {
10897         PyThreadState* __tstate = wxPyBeginAllowThreads();
10898         (arg1)->SetNativeFontInfo((wxNativeFontInfo const &)*arg2);
10899
10900         wxPyEndAllowThreads(__tstate);
10901         if (PyErr_Occurred()) SWIG_fail;
10902     }
10903     Py_INCREF(Py_None); resultobj = Py_None;
10904     return resultobj;
10905     fail:
10906     return NULL;
10907 }
10908
10909
10910 static PyObject *_wrap_Font_SetNativeFontInfoFromString(PyObject *, PyObject *args, PyObject *kwargs) {
10911     PyObject *resultobj;
10912     wxFont *arg1 = (wxFont *) 0 ;
10913     wxString *arg2 = 0 ;
10914     bool temp2 = false ;
10915     PyObject * obj0 = 0 ;
10916     PyObject * obj1 = 0 ;
10917     char *kwnames[] = {
10918         (char *) "self",(char *) "info", NULL
10919     };
10920
10921     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoFromString",kwnames,&obj0,&obj1)) goto fail;
10922     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10923     if (SWIG_arg_fail(1)) SWIG_fail;
10924     {
10925         arg2 = wxString_in_helper(obj1);
10926         if (arg2 == NULL) SWIG_fail;
10927         temp2 = true;
10928     }
10929     {
10930         PyThreadState* __tstate = wxPyBeginAllowThreads();
10931         (arg1)->SetNativeFontInfo((wxString const &)*arg2);
10932
10933         wxPyEndAllowThreads(__tstate);
10934         if (PyErr_Occurred()) SWIG_fail;
10935     }
10936     Py_INCREF(Py_None); resultobj = Py_None;
10937     {
10938         if (temp2)
10939         delete arg2;
10940     }
10941     return resultobj;
10942     fail:
10943     {
10944         if (temp2)
10945         delete arg2;
10946     }
10947     return NULL;
10948 }
10949
10950
10951 static PyObject *_wrap_Font_SetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10952     PyObject *resultobj;
10953     wxFont *arg1 = (wxFont *) 0 ;
10954     wxString *arg2 = 0 ;
10955     bool temp2 = false ;
10956     PyObject * obj0 = 0 ;
10957     PyObject * obj1 = 0 ;
10958     char *kwnames[] = {
10959         (char *) "self",(char *) "info", NULL
10960     };
10961
10962     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoUserDesc",kwnames,&obj0,&obj1)) goto fail;
10963     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10964     if (SWIG_arg_fail(1)) SWIG_fail;
10965     {
10966         arg2 = wxString_in_helper(obj1);
10967         if (arg2 == NULL) SWIG_fail;
10968         temp2 = true;
10969     }
10970     {
10971         PyThreadState* __tstate = wxPyBeginAllowThreads();
10972         (arg1)->SetNativeFontInfoUserDesc((wxString const &)*arg2);
10973
10974         wxPyEndAllowThreads(__tstate);
10975         if (PyErr_Occurred()) SWIG_fail;
10976     }
10977     Py_INCREF(Py_None); resultobj = Py_None;
10978     {
10979         if (temp2)
10980         delete arg2;
10981     }
10982     return resultobj;
10983     fail:
10984     {
10985         if (temp2)
10986         delete arg2;
10987     }
10988     return NULL;
10989 }
10990
10991
10992 static PyObject *_wrap_Font_GetFamilyString(PyObject *, PyObject *args, PyObject *kwargs) {
10993     PyObject *resultobj;
10994     wxFont *arg1 = (wxFont *) 0 ;
10995     wxString result;
10996     PyObject * obj0 = 0 ;
10997     char *kwnames[] = {
10998         (char *) "self", NULL
10999     };
11000
11001     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamilyString",kwnames,&obj0)) goto fail;
11002     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11003     if (SWIG_arg_fail(1)) SWIG_fail;
11004     {
11005         PyThreadState* __tstate = wxPyBeginAllowThreads();
11006         result = ((wxFont const *)arg1)->GetFamilyString();
11007
11008         wxPyEndAllowThreads(__tstate);
11009         if (PyErr_Occurred()) SWIG_fail;
11010     }
11011     {
11012 #if wxUSE_UNICODE
11013         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11014 #else
11015         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11016 #endif
11017     }
11018     return resultobj;
11019     fail:
11020     return NULL;
11021 }
11022
11023
11024 static PyObject *_wrap_Font_GetStyleString(PyObject *, PyObject *args, PyObject *kwargs) {
11025     PyObject *resultobj;
11026     wxFont *arg1 = (wxFont *) 0 ;
11027     wxString result;
11028     PyObject * obj0 = 0 ;
11029     char *kwnames[] = {
11030         (char *) "self", NULL
11031     };
11032
11033     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyleString",kwnames,&obj0)) goto fail;
11034     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11035     if (SWIG_arg_fail(1)) SWIG_fail;
11036     {
11037         PyThreadState* __tstate = wxPyBeginAllowThreads();
11038         result = ((wxFont const *)arg1)->GetStyleString();
11039
11040         wxPyEndAllowThreads(__tstate);
11041         if (PyErr_Occurred()) SWIG_fail;
11042     }
11043     {
11044 #if wxUSE_UNICODE
11045         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11046 #else
11047         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11048 #endif
11049     }
11050     return resultobj;
11051     fail:
11052     return NULL;
11053 }
11054
11055
11056 static PyObject *_wrap_Font_GetWeightString(PyObject *, PyObject *args, PyObject *kwargs) {
11057     PyObject *resultobj;
11058     wxFont *arg1 = (wxFont *) 0 ;
11059     wxString result;
11060     PyObject * obj0 = 0 ;
11061     char *kwnames[] = {
11062         (char *) "self", NULL
11063     };
11064
11065     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeightString",kwnames,&obj0)) goto fail;
11066     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11067     if (SWIG_arg_fail(1)) SWIG_fail;
11068     {
11069         PyThreadState* __tstate = wxPyBeginAllowThreads();
11070         result = ((wxFont const *)arg1)->GetWeightString();
11071
11072         wxPyEndAllowThreads(__tstate);
11073         if (PyErr_Occurred()) SWIG_fail;
11074     }
11075     {
11076 #if wxUSE_UNICODE
11077         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11078 #else
11079         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11080 #endif
11081     }
11082     return resultobj;
11083     fail:
11084     return NULL;
11085 }
11086
11087
11088 static PyObject *_wrap_Font_SetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
11089     PyObject *resultobj;
11090     wxFont *arg1 = (wxFont *) 0 ;
11091     bool arg2 = (bool) true ;
11092     PyObject * obj0 = 0 ;
11093     PyObject * obj1 = 0 ;
11094     char *kwnames[] = {
11095         (char *) "self",(char *) "no", NULL
11096     };
11097
11098     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Font_SetNoAntiAliasing",kwnames,&obj0,&obj1)) goto fail;
11099     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11100     if (SWIG_arg_fail(1)) SWIG_fail;
11101     if (obj1) {
11102         {
11103             arg2 = (bool)(SWIG_As_bool(obj1));
11104             if (SWIG_arg_fail(2)) SWIG_fail;
11105         }
11106     }
11107     {
11108         PyThreadState* __tstate = wxPyBeginAllowThreads();
11109         (arg1)->SetNoAntiAliasing(arg2);
11110
11111         wxPyEndAllowThreads(__tstate);
11112         if (PyErr_Occurred()) SWIG_fail;
11113     }
11114     Py_INCREF(Py_None); resultobj = Py_None;
11115     return resultobj;
11116     fail:
11117     return NULL;
11118 }
11119
11120
11121 static PyObject *_wrap_Font_GetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
11122     PyObject *resultobj;
11123     wxFont *arg1 = (wxFont *) 0 ;
11124     bool result;
11125     PyObject * obj0 = 0 ;
11126     char *kwnames[] = {
11127         (char *) "self", NULL
11128     };
11129
11130     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNoAntiAliasing",kwnames,&obj0)) goto fail;
11131     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11132     if (SWIG_arg_fail(1)) SWIG_fail;
11133     {
11134         PyThreadState* __tstate = wxPyBeginAllowThreads();
11135         result = (bool)((wxFont const *)arg1)->GetNoAntiAliasing();
11136
11137         wxPyEndAllowThreads(__tstate);
11138         if (PyErr_Occurred()) SWIG_fail;
11139     }
11140     {
11141         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11142     }
11143     return resultobj;
11144     fail:
11145     return NULL;
11146 }
11147
11148
11149 static PyObject *_wrap_Font_GetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11150     PyObject *resultobj;
11151     wxFontEncoding result;
11152     char *kwnames[] = {
11153         NULL
11154     };
11155
11156     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Font_GetDefaultEncoding",kwnames)) goto fail;
11157     {
11158         if (!wxPyCheckForApp()) SWIG_fail;
11159         PyThreadState* __tstate = wxPyBeginAllowThreads();
11160         result = (wxFontEncoding)wxFont::GetDefaultEncoding();
11161
11162         wxPyEndAllowThreads(__tstate);
11163         if (PyErr_Occurred()) SWIG_fail;
11164     }
11165     resultobj = SWIG_From_int((result));
11166     return resultobj;
11167     fail:
11168     return NULL;
11169 }
11170
11171
11172 static PyObject *_wrap_Font_SetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11173     PyObject *resultobj;
11174     wxFontEncoding arg1 ;
11175     PyObject * obj0 = 0 ;
11176     char *kwnames[] = {
11177         (char *) "encoding", NULL
11178     };
11179
11180     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_SetDefaultEncoding",kwnames,&obj0)) goto fail;
11181     {
11182         arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
11183         if (SWIG_arg_fail(1)) SWIG_fail;
11184     }
11185     {
11186         if (!wxPyCheckForApp()) SWIG_fail;
11187         PyThreadState* __tstate = wxPyBeginAllowThreads();
11188         wxFont::SetDefaultEncoding((wxFontEncoding )arg1);
11189
11190         wxPyEndAllowThreads(__tstate);
11191         if (PyErr_Occurred()) SWIG_fail;
11192     }
11193     Py_INCREF(Py_None); resultobj = Py_None;
11194     return resultobj;
11195     fail:
11196     return NULL;
11197 }
11198
11199
11200 static PyObject * Font_swigregister(PyObject *, PyObject *args) {
11201     PyObject *obj;
11202     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11203     SWIG_TypeClientData(SWIGTYPE_p_wxFont, obj);
11204     Py_INCREF(obj);
11205     return Py_BuildValue((char *)"");
11206 }
11207 static PyObject *_wrap_new_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
11208     PyObject *resultobj;
11209     wxPyFontEnumerator *result;
11210     char *kwnames[] = {
11211         NULL
11212     };
11213
11214     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontEnumerator",kwnames)) goto fail;
11215     {
11216         if (!wxPyCheckForApp()) SWIG_fail;
11217         PyThreadState* __tstate = wxPyBeginAllowThreads();
11218         result = (wxPyFontEnumerator *)new wxPyFontEnumerator();
11219
11220         wxPyEndAllowThreads(__tstate);
11221         if (PyErr_Occurred()) SWIG_fail;
11222     }
11223     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFontEnumerator, 1);
11224     return resultobj;
11225     fail:
11226     return NULL;
11227 }
11228
11229
11230 static PyObject *_wrap_delete_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
11231     PyObject *resultobj;
11232     wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11233     PyObject * obj0 = 0 ;
11234     char *kwnames[] = {
11235         (char *) "self", NULL
11236     };
11237
11238     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontEnumerator",kwnames,&obj0)) goto fail;
11239     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11240     if (SWIG_arg_fail(1)) SWIG_fail;
11241     {
11242         PyThreadState* __tstate = wxPyBeginAllowThreads();
11243         delete arg1;
11244
11245         wxPyEndAllowThreads(__tstate);
11246         if (PyErr_Occurred()) SWIG_fail;
11247     }
11248     Py_INCREF(Py_None); resultobj = Py_None;
11249     return resultobj;
11250     fail:
11251     return NULL;
11252 }
11253
11254
11255 static PyObject *_wrap_FontEnumerator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11256     PyObject *resultobj;
11257     wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11258     PyObject *arg2 = (PyObject *) 0 ;
11259     PyObject *arg3 = (PyObject *) 0 ;
11260     bool arg4 ;
11261     PyObject * obj0 = 0 ;
11262     PyObject * obj1 = 0 ;
11263     PyObject * obj2 = 0 ;
11264     PyObject * obj3 = 0 ;
11265     char *kwnames[] = {
11266         (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11267     };
11268
11269     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FontEnumerator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11270     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11271     if (SWIG_arg_fail(1)) SWIG_fail;
11272     arg2 = obj1;
11273     arg3 = obj2;
11274     {
11275         arg4 = (bool)(SWIG_As_bool(obj3));
11276         if (SWIG_arg_fail(4)) SWIG_fail;
11277     }
11278     {
11279         PyThreadState* __tstate = wxPyBeginAllowThreads();
11280         (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11281
11282         wxPyEndAllowThreads(__tstate);
11283         if (PyErr_Occurred()) SWIG_fail;
11284     }
11285     Py_INCREF(Py_None); resultobj = Py_None;
11286     return resultobj;
11287     fail:
11288     return NULL;
11289 }
11290
11291
11292 static PyObject *_wrap_FontEnumerator_EnumerateFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
11293     PyObject *resultobj;
11294     wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11295     wxFontEncoding arg2 = (wxFontEncoding) wxFONTENCODING_SYSTEM ;
11296     bool arg3 = (bool) false ;
11297     bool result;
11298     PyObject * obj0 = 0 ;
11299     PyObject * obj1 = 0 ;
11300     PyObject * obj2 = 0 ;
11301     char *kwnames[] = {
11302         (char *) "self",(char *) "encoding",(char *) "fixedWidthOnly", NULL
11303     };
11304
11305     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FontEnumerator_EnumerateFacenames",kwnames,&obj0,&obj1,&obj2)) goto fail;
11306     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11307     if (SWIG_arg_fail(1)) SWIG_fail;
11308     if (obj1) {
11309         {
11310             arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
11311             if (SWIG_arg_fail(2)) SWIG_fail;
11312         }
11313     }
11314     if (obj2) {
11315         {
11316             arg3 = (bool)(SWIG_As_bool(obj2));
11317             if (SWIG_arg_fail(3)) SWIG_fail;
11318         }
11319     }
11320     {
11321         PyThreadState* __tstate = wxPyBeginAllowThreads();
11322         result = (bool)(arg1)->EnumerateFacenames((wxFontEncoding )arg2,arg3);
11323
11324         wxPyEndAllowThreads(__tstate);
11325         if (PyErr_Occurred()) SWIG_fail;
11326     }
11327     {
11328         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11329     }
11330     return resultobj;
11331     fail:
11332     return NULL;
11333 }
11334
11335
11336 static PyObject *_wrap_FontEnumerator_EnumerateEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
11337     PyObject *resultobj;
11338     wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11339     wxString const &arg2_defvalue = wxPyEmptyString ;
11340     wxString *arg2 = (wxString *) &arg2_defvalue ;
11341     bool result;
11342     bool temp2 = false ;
11343     PyObject * obj0 = 0 ;
11344     PyObject * obj1 = 0 ;
11345     char *kwnames[] = {
11346         (char *) "self",(char *) "facename", NULL
11347     };
11348
11349     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FontEnumerator_EnumerateEncodings",kwnames,&obj0,&obj1)) goto fail;
11350     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11351     if (SWIG_arg_fail(1)) SWIG_fail;
11352     if (obj1) {
11353         {
11354             arg2 = wxString_in_helper(obj1);
11355             if (arg2 == NULL) SWIG_fail;
11356             temp2 = true;
11357         }
11358     }
11359     {
11360         PyThreadState* __tstate = wxPyBeginAllowThreads();
11361         result = (bool)(arg1)->EnumerateEncodings((wxString const &)*arg2);
11362
11363         wxPyEndAllowThreads(__tstate);
11364         if (PyErr_Occurred()) SWIG_fail;
11365     }
11366     {
11367         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11368     }
11369     {
11370         if (temp2)
11371         delete arg2;
11372     }
11373     return resultobj;
11374     fail:
11375     {
11376         if (temp2)
11377         delete arg2;
11378     }
11379     return NULL;
11380 }
11381
11382
11383 static PyObject *_wrap_FontEnumerator_GetEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
11384     PyObject *resultobj;
11385     wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11386     PyObject *result;
11387     PyObject * obj0 = 0 ;
11388     char *kwnames[] = {
11389         (char *) "self", NULL
11390     };
11391
11392     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetEncodings",kwnames,&obj0)) goto fail;
11393     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11394     if (SWIG_arg_fail(1)) SWIG_fail;
11395     {
11396         PyThreadState* __tstate = wxPyBeginAllowThreads();
11397         result = (PyObject *)wxPyFontEnumerator_GetEncodings(arg1);
11398
11399         wxPyEndAllowThreads(__tstate);
11400         if (PyErr_Occurred()) SWIG_fail;
11401     }
11402     resultobj = result;
11403     return resultobj;
11404     fail:
11405     return NULL;
11406 }
11407
11408
11409 static PyObject *_wrap_FontEnumerator_GetFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
11410     PyObject *resultobj;
11411     wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11412     PyObject *result;
11413     PyObject * obj0 = 0 ;
11414     char *kwnames[] = {
11415         (char *) "self", NULL
11416     };
11417
11418     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetFacenames",kwnames,&obj0)) goto fail;
11419     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11420     if (SWIG_arg_fail(1)) SWIG_fail;
11421     {
11422         PyThreadState* __tstate = wxPyBeginAllowThreads();
11423         result = (PyObject *)wxPyFontEnumerator_GetFacenames(arg1);
11424
11425         wxPyEndAllowThreads(__tstate);
11426         if (PyErr_Occurred()) SWIG_fail;
11427     }
11428     resultobj = result;
11429     return resultobj;
11430     fail:
11431     return NULL;
11432 }
11433
11434
11435 static PyObject * FontEnumerator_swigregister(PyObject *, PyObject *args) {
11436     PyObject *obj;
11437     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11438     SWIG_TypeClientData(SWIGTYPE_p_wxPyFontEnumerator, obj);
11439     Py_INCREF(obj);
11440     return Py_BuildValue((char *)"");
11441 }
11442 static PyObject *_wrap_LanguageInfo_Language_set(PyObject *, PyObject *args, PyObject *kwargs) {
11443     PyObject *resultobj;
11444     wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11445     int arg2 ;
11446     PyObject * obj0 = 0 ;
11447     PyObject * obj1 = 0 ;
11448     char *kwnames[] = {
11449         (char *) "self",(char *) "Language", NULL
11450     };
11451
11452     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Language_set",kwnames,&obj0,&obj1)) goto fail;
11453     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11454     if (SWIG_arg_fail(1)) SWIG_fail;
11455     {
11456         arg2 = (int)(SWIG_As_int(obj1));
11457         if (SWIG_arg_fail(2)) SWIG_fail;
11458     }
11459     if (arg1) (arg1)->Language = arg2;
11460
11461     Py_INCREF(Py_None); resultobj = Py_None;
11462     return resultobj;
11463     fail:
11464     return NULL;
11465 }
11466
11467
11468 static PyObject *_wrap_LanguageInfo_Language_get(PyObject *, PyObject *args, PyObject *kwargs) {
11469     PyObject *resultobj;
11470     wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11471     int result;
11472     PyObject * obj0 = 0 ;
11473     char *kwnames[] = {
11474         (char *) "self", NULL
11475     };
11476
11477     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Language_get",kwnames,&obj0)) goto fail;
11478     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11479     if (SWIG_arg_fail(1)) SWIG_fail;
11480     result = (int) ((arg1)->Language);
11481
11482     {
11483         resultobj = SWIG_From_int((int)(result));
11484     }
11485     return resultobj;
11486     fail:
11487     return NULL;
11488 }
11489
11490
11491 static PyObject *_wrap_LanguageInfo_CanonicalName_set(PyObject *, PyObject *args, PyObject *kwargs) {
11492     PyObject *resultobj;
11493     wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11494     wxString *arg2 = (wxString *) 0 ;
11495     bool temp2 = false ;
11496     PyObject * obj0 = 0 ;
11497     PyObject * obj1 = 0 ;
11498     char *kwnames[] = {
11499         (char *) "self",(char *) "CanonicalName", NULL
11500     };
11501
11502     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_CanonicalName_set",kwnames,&obj0,&obj1)) goto fail;
11503     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11504     if (SWIG_arg_fail(1)) SWIG_fail;
11505     {
11506         arg2 = wxString_in_helper(obj1);
11507         if (arg2 == NULL) SWIG_fail;
11508         temp2 = true;
11509     }
11510     if (arg1) (arg1)->CanonicalName = *arg2;
11511
11512     Py_INCREF(Py_None); resultobj = Py_None;
11513     {
11514         if (temp2)
11515         delete arg2;
11516     }
11517     return resultobj;
11518     fail:
11519     {
11520         if (temp2)
11521         delete arg2;
11522     }
11523     return NULL;
11524 }
11525
11526
11527 static PyObject *_wrap_LanguageInfo_CanonicalName_get(PyObject *, PyObject *args, PyObject *kwargs) {
11528     PyObject *resultobj;
11529     wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11530     wxString *result;
11531     PyObject * obj0 = 0 ;
11532     char *kwnames[] = {
11533         (char *) "self", NULL
11534     };
11535
11536     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_CanonicalName_get",kwnames,&obj0)) 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     result = (wxString *)& ((arg1)->CanonicalName);
11540
11541     {
11542 #if wxUSE_UNICODE
11543         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11544 #else
11545         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11546 #endif
11547     }
11548     return resultobj;
11549     fail:
11550     return NULL;
11551 }
11552
11553
11554 static PyObject *_wrap_LanguageInfo_Description_set(PyObject *, PyObject *args, PyObject *kwargs) {
11555     PyObject *resultobj;
11556     wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11557     wxString *arg2 = (wxString *) 0 ;
11558     bool temp2 = false ;
11559     PyObject * obj0 = 0 ;
11560     PyObject * obj1 = 0 ;
11561     char *kwnames[] = {
11562         (char *) "self",(char *) "Description", NULL
11563     };
11564
11565     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Description_set",kwnames,&obj0,&obj1)) goto fail;
11566     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11567     if (SWIG_arg_fail(1)) SWIG_fail;
11568     {
11569         arg2 = wxString_in_helper(obj1);
11570         if (arg2 == NULL) SWIG_fail;
11571         temp2 = true;
11572     }
11573     if (arg1) (arg1)->Description = *arg2;
11574
11575     Py_INCREF(Py_None); resultobj = Py_None;
11576     {
11577         if (temp2)
11578         delete arg2;
11579     }
11580     return resultobj;
11581     fail:
11582     {
11583         if (temp2)
11584         delete arg2;
11585     }
11586     return NULL;
11587 }
11588
11589
11590 static PyObject *_wrap_LanguageInfo_Description_get(PyObject *, PyObject *args, PyObject *kwargs) {
11591     PyObject *resultobj;
11592     wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11593     wxString *result;
11594     PyObject * obj0 = 0 ;
11595     char *kwnames[] = {
11596         (char *) "self", NULL
11597     };
11598
11599     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Description_get",kwnames,&obj0)) 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     result = (wxString *)& ((arg1)->Description);
11603
11604     {
11605 #if wxUSE_UNICODE
11606         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11607 #else
11608         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11609 #endif
11610     }
11611     return resultobj;
11612     fail:
11613     return NULL;
11614 }
11615
11616
11617 static PyObject * LanguageInfo_swigregister(PyObject *, PyObject *args) {
11618     PyObject *obj;
11619     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11620     SWIG_TypeClientData(SWIGTYPE_p_wxLanguageInfo, obj);
11621     Py_INCREF(obj);
11622     return Py_BuildValue((char *)"");
11623 }
11624 static PyObject *_wrap_new_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11625     PyObject *resultobj;
11626     int arg1 = (int) -1 ;
11627     int arg2 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11628     wxLocale *result;
11629     PyObject * obj0 = 0 ;
11630     PyObject * obj1 = 0 ;
11631     char *kwnames[] = {
11632         (char *) "language",(char *) "flags", NULL
11633     };
11634
11635     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Locale",kwnames,&obj0,&obj1)) goto fail;
11636     if (obj0) {
11637         {
11638             arg1 = (int)(SWIG_As_int(obj0));
11639             if (SWIG_arg_fail(1)) SWIG_fail;
11640         }
11641     }
11642     if (obj1) {
11643         {
11644             arg2 = (int)(SWIG_As_int(obj1));
11645             if (SWIG_arg_fail(2)) SWIG_fail;
11646         }
11647     }
11648     {
11649         PyThreadState* __tstate = wxPyBeginAllowThreads();
11650         result = (wxLocale *)new_wxLocale(arg1,arg2);
11651
11652         wxPyEndAllowThreads(__tstate);
11653         if (PyErr_Occurred()) SWIG_fail;
11654     }
11655     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 1);
11656     return resultobj;
11657     fail:
11658     return NULL;
11659 }
11660
11661
11662 static PyObject *_wrap_delete_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11663     PyObject *resultobj;
11664     wxLocale *arg1 = (wxLocale *) 0 ;
11665     PyObject * obj0 = 0 ;
11666     char *kwnames[] = {
11667         (char *) "self", NULL
11668     };
11669
11670     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Locale",kwnames,&obj0)) goto fail;
11671     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11672     if (SWIG_arg_fail(1)) SWIG_fail;
11673     {
11674         PyThreadState* __tstate = wxPyBeginAllowThreads();
11675         delete arg1;
11676
11677         wxPyEndAllowThreads(__tstate);
11678         if (PyErr_Occurred()) SWIG_fail;
11679     }
11680     Py_INCREF(Py_None); resultobj = Py_None;
11681     return resultobj;
11682     fail:
11683     return NULL;
11684 }
11685
11686
11687 static PyObject *_wrap_Locale_Init1(PyObject *, PyObject *args, PyObject *kwargs) {
11688     PyObject *resultobj;
11689     wxLocale *arg1 = (wxLocale *) 0 ;
11690     wxString *arg2 = 0 ;
11691     wxString const &arg3_defvalue = wxPyEmptyString ;
11692     wxString *arg3 = (wxString *) &arg3_defvalue ;
11693     wxString const &arg4_defvalue = wxPyEmptyString ;
11694     wxString *arg4 = (wxString *) &arg4_defvalue ;
11695     bool arg5 = (bool) true ;
11696     bool arg6 = (bool) false ;
11697     bool result;
11698     bool temp2 = false ;
11699     bool temp3 = false ;
11700     bool temp4 = false ;
11701     PyObject * obj0 = 0 ;
11702     PyObject * obj1 = 0 ;
11703     PyObject * obj2 = 0 ;
11704     PyObject * obj3 = 0 ;
11705     PyObject * obj4 = 0 ;
11706     PyObject * obj5 = 0 ;
11707     char *kwnames[] = {
11708         (char *) "self",(char *) "szName",(char *) "szShort",(char *) "szLocale",(char *) "bLoadDefault",(char *) "bConvertEncoding", NULL
11709     };
11710
11711     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Locale_Init1",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11712     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11713     if (SWIG_arg_fail(1)) SWIG_fail;
11714     {
11715         arg2 = wxString_in_helper(obj1);
11716         if (arg2 == NULL) SWIG_fail;
11717         temp2 = true;
11718     }
11719     if (obj2) {
11720         {
11721             arg3 = wxString_in_helper(obj2);
11722             if (arg3 == NULL) SWIG_fail;
11723             temp3 = true;
11724         }
11725     }
11726     if (obj3) {
11727         {
11728             arg4 = wxString_in_helper(obj3);
11729             if (arg4 == NULL) SWIG_fail;
11730             temp4 = true;
11731         }
11732     }
11733     if (obj4) {
11734         {
11735             arg5 = (bool)(SWIG_As_bool(obj4));
11736             if (SWIG_arg_fail(5)) SWIG_fail;
11737         }
11738     }
11739     if (obj5) {
11740         {
11741             arg6 = (bool)(SWIG_As_bool(obj5));
11742             if (SWIG_arg_fail(6)) SWIG_fail;
11743         }
11744     }
11745     {
11746         PyThreadState* __tstate = wxPyBeginAllowThreads();
11747         result = (bool)wxLocale_Init1(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
11748
11749         wxPyEndAllowThreads(__tstate);
11750         if (PyErr_Occurred()) SWIG_fail;
11751     }
11752     {
11753         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11754     }
11755     {
11756         if (temp2)
11757         delete arg2;
11758     }
11759     {
11760         if (temp3)
11761         delete arg3;
11762     }
11763     {
11764         if (temp4)
11765         delete arg4;
11766     }
11767     return resultobj;
11768     fail:
11769     {
11770         if (temp2)
11771         delete arg2;
11772     }
11773     {
11774         if (temp3)
11775         delete arg3;
11776     }
11777     {
11778         if (temp4)
11779         delete arg4;
11780     }
11781     return NULL;
11782 }
11783
11784
11785 static PyObject *_wrap_Locale_Init2(PyObject *, PyObject *args, PyObject *kwargs) {
11786     PyObject *resultobj;
11787     wxLocale *arg1 = (wxLocale *) 0 ;
11788     int arg2 = (int) wxLANGUAGE_DEFAULT ;
11789     int arg3 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11790     bool result;
11791     PyObject * obj0 = 0 ;
11792     PyObject * obj1 = 0 ;
11793     PyObject * obj2 = 0 ;
11794     char *kwnames[] = {
11795         (char *) "self",(char *) "language",(char *) "flags", NULL
11796     };
11797
11798     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Locale_Init2",kwnames,&obj0,&obj1,&obj2)) goto fail;
11799     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11800     if (SWIG_arg_fail(1)) SWIG_fail;
11801     if (obj1) {
11802         {
11803             arg2 = (int)(SWIG_As_int(obj1));
11804             if (SWIG_arg_fail(2)) SWIG_fail;
11805         }
11806     }
11807     if (obj2) {
11808         {
11809             arg3 = (int)(SWIG_As_int(obj2));
11810             if (SWIG_arg_fail(3)) SWIG_fail;
11811         }
11812     }
11813     {
11814         PyThreadState* __tstate = wxPyBeginAllowThreads();
11815         result = (bool)wxLocale_Init2(arg1,arg2,arg3);
11816
11817         wxPyEndAllowThreads(__tstate);
11818         if (PyErr_Occurred()) SWIG_fail;
11819     }
11820     {
11821         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11822     }
11823     return resultobj;
11824     fail:
11825     return NULL;
11826 }
11827
11828
11829 static PyObject *_wrap_Locale_GetSystemLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11830     PyObject *resultobj;
11831     int result;
11832     char *kwnames[] = {
11833         NULL
11834     };
11835
11836     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemLanguage",kwnames)) goto fail;
11837     {
11838         PyThreadState* __tstate = wxPyBeginAllowThreads();
11839         result = (int)wxLocale::GetSystemLanguage();
11840
11841         wxPyEndAllowThreads(__tstate);
11842         if (PyErr_Occurred()) SWIG_fail;
11843     }
11844     {
11845         resultobj = SWIG_From_int((int)(result));
11846     }
11847     return resultobj;
11848     fail:
11849     return NULL;
11850 }
11851
11852
11853 static PyObject *_wrap_Locale_GetSystemEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11854     PyObject *resultobj;
11855     wxFontEncoding result;
11856     char *kwnames[] = {
11857         NULL
11858     };
11859
11860     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncoding",kwnames)) goto fail;
11861     {
11862         PyThreadState* __tstate = wxPyBeginAllowThreads();
11863         result = (wxFontEncoding)wxLocale::GetSystemEncoding();
11864
11865         wxPyEndAllowThreads(__tstate);
11866         if (PyErr_Occurred()) SWIG_fail;
11867     }
11868     resultobj = SWIG_From_int((result));
11869     return resultobj;
11870     fail:
11871     return NULL;
11872 }
11873
11874
11875 static PyObject *_wrap_Locale_GetSystemEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
11876     PyObject *resultobj;
11877     wxString result;
11878     char *kwnames[] = {
11879         NULL
11880     };
11881
11882     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncodingName",kwnames)) goto fail;
11883     {
11884         PyThreadState* __tstate = wxPyBeginAllowThreads();
11885         result = wxLocale::GetSystemEncodingName();
11886
11887         wxPyEndAllowThreads(__tstate);
11888         if (PyErr_Occurred()) SWIG_fail;
11889     }
11890     {
11891 #if wxUSE_UNICODE
11892         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11893 #else
11894         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11895 #endif
11896     }
11897     return resultobj;
11898     fail:
11899     return NULL;
11900 }
11901
11902
11903 static PyObject *_wrap_Locale_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11904     PyObject *resultobj;
11905     wxLocale *arg1 = (wxLocale *) 0 ;
11906     bool result;
11907     PyObject * obj0 = 0 ;
11908     char *kwnames[] = {
11909         (char *) "self", NULL
11910     };
11911
11912     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_IsOk",kwnames,&obj0)) goto fail;
11913     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11914     if (SWIG_arg_fail(1)) SWIG_fail;
11915     {
11916         PyThreadState* __tstate = wxPyBeginAllowThreads();
11917         result = (bool)((wxLocale const *)arg1)->IsOk();
11918
11919         wxPyEndAllowThreads(__tstate);
11920         if (PyErr_Occurred()) SWIG_fail;
11921     }
11922     {
11923         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11924     }
11925     return resultobj;
11926     fail:
11927     return NULL;
11928 }
11929
11930
11931 static PyObject *_wrap_Locale_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11932     PyObject *resultobj;
11933     wxLocale *arg1 = (wxLocale *) 0 ;
11934     wxString result;
11935     PyObject * obj0 = 0 ;
11936     char *kwnames[] = {
11937         (char *) "self", NULL
11938     };
11939
11940     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLocale",kwnames,&obj0)) goto fail;
11941     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11942     if (SWIG_arg_fail(1)) SWIG_fail;
11943     {
11944         PyThreadState* __tstate = wxPyBeginAllowThreads();
11945         result = ((wxLocale const *)arg1)->GetLocale();
11946
11947         wxPyEndAllowThreads(__tstate);
11948         if (PyErr_Occurred()) SWIG_fail;
11949     }
11950     {
11951 #if wxUSE_UNICODE
11952         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11953 #else
11954         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11955 #endif
11956     }
11957     return resultobj;
11958     fail:
11959     return NULL;
11960 }
11961
11962
11963 static PyObject *_wrap_Locale_GetLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11964     PyObject *resultobj;
11965     wxLocale *arg1 = (wxLocale *) 0 ;
11966     int result;
11967     PyObject * obj0 = 0 ;
11968     char *kwnames[] = {
11969         (char *) "self", NULL
11970     };
11971
11972     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguage",kwnames,&obj0)) goto fail;
11973     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11974     if (SWIG_arg_fail(1)) SWIG_fail;
11975     {
11976         PyThreadState* __tstate = wxPyBeginAllowThreads();
11977         result = (int)((wxLocale const *)arg1)->GetLanguage();
11978
11979         wxPyEndAllowThreads(__tstate);
11980         if (PyErr_Occurred()) SWIG_fail;
11981     }
11982     {
11983         resultobj = SWIG_From_int((int)(result));
11984     }
11985     return resultobj;
11986     fail:
11987     return NULL;
11988 }
11989
11990
11991 static PyObject *_wrap_Locale_GetSysName(PyObject *, PyObject *args, PyObject *kwargs) {
11992     PyObject *resultobj;
11993     wxLocale *arg1 = (wxLocale *) 0 ;
11994     wxString result;
11995     PyObject * obj0 = 0 ;
11996     char *kwnames[] = {
11997         (char *) "self", NULL
11998     };
11999
12000     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetSysName",kwnames,&obj0)) goto fail;
12001     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12002     if (SWIG_arg_fail(1)) SWIG_fail;
12003     {
12004         PyThreadState* __tstate = wxPyBeginAllowThreads();
12005         result = ((wxLocale const *)arg1)->GetSysName();
12006
12007         wxPyEndAllowThreads(__tstate);
12008         if (PyErr_Occurred()) SWIG_fail;
12009     }
12010     {
12011 #if wxUSE_UNICODE
12012         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12013 #else
12014         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12015 #endif
12016     }
12017     return resultobj;
12018     fail:
12019     return NULL;
12020 }
12021
12022
12023 static PyObject *_wrap_Locale_GetCanonicalName(PyObject *, PyObject *args, PyObject *kwargs) {
12024     PyObject *resultobj;
12025     wxLocale *arg1 = (wxLocale *) 0 ;
12026     wxString result;
12027     PyObject * obj0 = 0 ;
12028     char *kwnames[] = {
12029         (char *) "self", NULL
12030     };
12031
12032     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetCanonicalName",kwnames,&obj0)) goto fail;
12033     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12034     if (SWIG_arg_fail(1)) SWIG_fail;
12035     {
12036         PyThreadState* __tstate = wxPyBeginAllowThreads();
12037         result = ((wxLocale const *)arg1)->GetCanonicalName();
12038
12039         wxPyEndAllowThreads(__tstate);
12040         if (PyErr_Occurred()) SWIG_fail;
12041     }
12042     {
12043 #if wxUSE_UNICODE
12044         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12045 #else
12046         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12047 #endif
12048     }
12049     return resultobj;
12050     fail:
12051     return NULL;
12052 }
12053
12054
12055 static PyObject *_wrap_Locale_AddCatalogLookupPathPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
12056     PyObject *resultobj;
12057     wxString *arg1 = 0 ;
12058     bool temp1 = false ;
12059     PyObject * obj0 = 0 ;
12060     char *kwnames[] = {
12061         (char *) "prefix", NULL
12062     };
12063
12064     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddCatalogLookupPathPrefix",kwnames,&obj0)) goto fail;
12065     {
12066         arg1 = wxString_in_helper(obj0);
12067         if (arg1 == NULL) SWIG_fail;
12068         temp1 = true;
12069     }
12070     {
12071         PyThreadState* __tstate = wxPyBeginAllowThreads();
12072         wxLocale::AddCatalogLookupPathPrefix((wxString const &)*arg1);
12073
12074         wxPyEndAllowThreads(__tstate);
12075         if (PyErr_Occurred()) SWIG_fail;
12076     }
12077     Py_INCREF(Py_None); resultobj = Py_None;
12078     {
12079         if (temp1)
12080         delete arg1;
12081     }
12082     return resultobj;
12083     fail:
12084     {
12085         if (temp1)
12086         delete arg1;
12087     }
12088     return NULL;
12089 }
12090
12091
12092 static PyObject *_wrap_Locale_AddCatalog(PyObject *, PyObject *args, PyObject *kwargs) {
12093     PyObject *resultobj;
12094     wxLocale *arg1 = (wxLocale *) 0 ;
12095     wxString *arg2 = 0 ;
12096     bool result;
12097     bool temp2 = false ;
12098     PyObject * obj0 = 0 ;
12099     PyObject * obj1 = 0 ;
12100     char *kwnames[] = {
12101         (char *) "self",(char *) "szDomain", NULL
12102     };
12103
12104     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_AddCatalog",kwnames,&obj0,&obj1)) goto fail;
12105     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12106     if (SWIG_arg_fail(1)) SWIG_fail;
12107     {
12108         arg2 = wxString_in_helper(obj1);
12109         if (arg2 == NULL) SWIG_fail;
12110         temp2 = true;
12111     }
12112     {
12113         PyThreadState* __tstate = wxPyBeginAllowThreads();
12114         result = (bool)(arg1)->AddCatalog((wxString const &)*arg2);
12115
12116         wxPyEndAllowThreads(__tstate);
12117         if (PyErr_Occurred()) SWIG_fail;
12118     }
12119     {
12120         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12121     }
12122     {
12123         if (temp2)
12124         delete arg2;
12125     }
12126     return resultobj;
12127     fail:
12128     {
12129         if (temp2)
12130         delete arg2;
12131     }
12132     return NULL;
12133 }
12134
12135
12136 static PyObject *_wrap_Locale_IsLoaded(PyObject *, PyObject *args, PyObject *kwargs) {
12137     PyObject *resultobj;
12138     wxLocale *arg1 = (wxLocale *) 0 ;
12139     wxString *arg2 = 0 ;
12140     bool result;
12141     bool temp2 = false ;
12142     PyObject * obj0 = 0 ;
12143     PyObject * obj1 = 0 ;
12144     char *kwnames[] = {
12145         (char *) "self",(char *) "szDomain", NULL
12146     };
12147
12148     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_IsLoaded",kwnames,&obj0,&obj1)) goto fail;
12149     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12150     if (SWIG_arg_fail(1)) SWIG_fail;
12151     {
12152         arg2 = wxString_in_helper(obj1);
12153         if (arg2 == NULL) SWIG_fail;
12154         temp2 = true;
12155     }
12156     {
12157         PyThreadState* __tstate = wxPyBeginAllowThreads();
12158         result = (bool)((wxLocale const *)arg1)->IsLoaded((wxString const &)*arg2);
12159
12160         wxPyEndAllowThreads(__tstate);
12161         if (PyErr_Occurred()) SWIG_fail;
12162     }
12163     {
12164         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12165     }
12166     {
12167         if (temp2)
12168         delete arg2;
12169     }
12170     return resultobj;
12171     fail:
12172     {
12173         if (temp2)
12174         delete arg2;
12175     }
12176     return NULL;
12177 }
12178
12179
12180 static PyObject *_wrap_Locale_GetLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
12181     PyObject *resultobj;
12182     int arg1 ;
12183     wxLanguageInfo *result;
12184     PyObject * obj0 = 0 ;
12185     char *kwnames[] = {
12186         (char *) "lang", NULL
12187     };
12188
12189     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageInfo",kwnames,&obj0)) goto fail;
12190     {
12191         arg1 = (int)(SWIG_As_int(obj0));
12192         if (SWIG_arg_fail(1)) SWIG_fail;
12193     }
12194     {
12195         PyThreadState* __tstate = wxPyBeginAllowThreads();
12196         result = (wxLanguageInfo *)wxLocale::GetLanguageInfo(arg1);
12197
12198         wxPyEndAllowThreads(__tstate);
12199         if (PyErr_Occurred()) SWIG_fail;
12200     }
12201     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
12202     return resultobj;
12203     fail:
12204     return NULL;
12205 }
12206
12207
12208 static PyObject *_wrap_Locale_GetLanguageName(PyObject *, PyObject *args, PyObject *kwargs) {
12209     PyObject *resultobj;
12210     int arg1 ;
12211     wxString result;
12212     PyObject * obj0 = 0 ;
12213     char *kwnames[] = {
12214         (char *) "lang", NULL
12215     };
12216
12217     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageName",kwnames,&obj0)) goto fail;
12218     {
12219         arg1 = (int)(SWIG_As_int(obj0));
12220         if (SWIG_arg_fail(1)) SWIG_fail;
12221     }
12222     {
12223         PyThreadState* __tstate = wxPyBeginAllowThreads();
12224         result = wxLocale::GetLanguageName(arg1);
12225
12226         wxPyEndAllowThreads(__tstate);
12227         if (PyErr_Occurred()) SWIG_fail;
12228     }
12229     {
12230 #if wxUSE_UNICODE
12231         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12232 #else
12233         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12234 #endif
12235     }
12236     return resultobj;
12237     fail:
12238     return NULL;
12239 }
12240
12241
12242 static PyObject *_wrap_Locale_FindLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
12243     PyObject *resultobj;
12244     wxString *arg1 = 0 ;
12245     wxLanguageInfo *result;
12246     bool temp1 = false ;
12247     PyObject * obj0 = 0 ;
12248     char *kwnames[] = {
12249         (char *) "locale", NULL
12250     };
12251
12252     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_FindLanguageInfo",kwnames,&obj0)) goto fail;
12253     {
12254         arg1 = wxString_in_helper(obj0);
12255         if (arg1 == NULL) SWIG_fail;
12256         temp1 = true;
12257     }
12258     {
12259         PyThreadState* __tstate = wxPyBeginAllowThreads();
12260         result = (wxLanguageInfo *)wxLocale::FindLanguageInfo((wxString const &)*arg1);
12261
12262         wxPyEndAllowThreads(__tstate);
12263         if (PyErr_Occurred()) SWIG_fail;
12264     }
12265     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
12266     {
12267         if (temp1)
12268         delete arg1;
12269     }
12270     return resultobj;
12271     fail:
12272     {
12273         if (temp1)
12274         delete arg1;
12275     }
12276     return NULL;
12277 }
12278
12279
12280 static PyObject *_wrap_Locale_AddLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
12281     PyObject *resultobj;
12282     wxLanguageInfo *arg1 = 0 ;
12283     PyObject * obj0 = 0 ;
12284     char *kwnames[] = {
12285         (char *) "info", NULL
12286     };
12287
12288     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddLanguage",kwnames,&obj0)) goto fail;
12289     {
12290         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
12291         if (SWIG_arg_fail(1)) SWIG_fail;
12292         if (arg1 == NULL) {
12293             SWIG_null_ref("wxLanguageInfo");
12294         }
12295         if (SWIG_arg_fail(1)) SWIG_fail;
12296     }
12297     {
12298         PyThreadState* __tstate = wxPyBeginAllowThreads();
12299         wxLocale::AddLanguage((wxLanguageInfo const &)*arg1);
12300
12301         wxPyEndAllowThreads(__tstate);
12302         if (PyErr_Occurred()) SWIG_fail;
12303     }
12304     Py_INCREF(Py_None); resultobj = Py_None;
12305     return resultobj;
12306     fail:
12307     return NULL;
12308 }
12309
12310
12311 static PyObject *_wrap_Locale_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
12312     PyObject *resultobj;
12313     wxLocale *arg1 = (wxLocale *) 0 ;
12314     wxString *arg2 = 0 ;
12315     wxString const &arg3_defvalue = wxPyEmptyString ;
12316     wxString *arg3 = (wxString *) &arg3_defvalue ;
12317     wxString result;
12318     bool temp2 = false ;
12319     bool temp3 = false ;
12320     PyObject * obj0 = 0 ;
12321     PyObject * obj1 = 0 ;
12322     PyObject * obj2 = 0 ;
12323     char *kwnames[] = {
12324         (char *) "self",(char *) "szOrigString",(char *) "szDomain", NULL
12325     };
12326
12327     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Locale_GetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
12328     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12329     if (SWIG_arg_fail(1)) SWIG_fail;
12330     {
12331         arg2 = wxString_in_helper(obj1);
12332         if (arg2 == NULL) SWIG_fail;
12333         temp2 = true;
12334     }
12335     if (obj2) {
12336         {
12337             arg3 = wxString_in_helper(obj2);
12338             if (arg3 == NULL) SWIG_fail;
12339             temp3 = true;
12340         }
12341     }
12342     {
12343         PyThreadState* __tstate = wxPyBeginAllowThreads();
12344         result = ((wxLocale const *)arg1)->GetString((wxString const &)*arg2,(wxString const &)*arg3);
12345
12346         wxPyEndAllowThreads(__tstate);
12347         if (PyErr_Occurred()) SWIG_fail;
12348     }
12349     {
12350 #if wxUSE_UNICODE
12351         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12352 #else
12353         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12354 #endif
12355     }
12356     {
12357         if (temp2)
12358         delete arg2;
12359     }
12360     {
12361         if (temp3)
12362         delete arg3;
12363     }
12364     return resultobj;
12365     fail:
12366     {
12367         if (temp2)
12368         delete arg2;
12369     }
12370     {
12371         if (temp3)
12372         delete arg3;
12373     }
12374     return NULL;
12375 }
12376
12377
12378 static PyObject *_wrap_Locale_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
12379     PyObject *resultobj;
12380     wxLocale *arg1 = (wxLocale *) 0 ;
12381     wxString *result;
12382     PyObject * obj0 = 0 ;
12383     char *kwnames[] = {
12384         (char *) "self", NULL
12385     };
12386
12387     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetName",kwnames,&obj0)) goto fail;
12388     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12389     if (SWIG_arg_fail(1)) SWIG_fail;
12390     {
12391         PyThreadState* __tstate = wxPyBeginAllowThreads();
12392         {
12393             wxString const &_result_ref = ((wxLocale const *)arg1)->GetName();
12394             result = (wxString *) &_result_ref;
12395         }
12396
12397         wxPyEndAllowThreads(__tstate);
12398         if (PyErr_Occurred()) SWIG_fail;
12399     }
12400     {
12401 #if wxUSE_UNICODE
12402         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12403 #else
12404         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12405 #endif
12406     }
12407     return resultobj;
12408     fail:
12409     return NULL;
12410 }
12411
12412
12413 static PyObject * Locale_swigregister(PyObject *, PyObject *args) {
12414     PyObject *obj;
12415     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12416     SWIG_TypeClientData(SWIGTYPE_p_wxLocale, obj);
12417     Py_INCREF(obj);
12418     return Py_BuildValue((char *)"");
12419 }
12420 static PyObject *_wrap_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
12421     PyObject *resultobj;
12422     wxLocale *result;
12423     char *kwnames[] = {
12424         NULL
12425     };
12426
12427     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocale",kwnames)) goto fail;
12428     {
12429         PyThreadState* __tstate = wxPyBeginAllowThreads();
12430         result = (wxLocale *)wxGetLocale();
12431
12432         wxPyEndAllowThreads(__tstate);
12433         if (PyErr_Occurred()) SWIG_fail;
12434     }
12435     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 0);
12436     return resultobj;
12437     fail:
12438     return NULL;
12439 }
12440
12441
12442 static PyObject *_wrap_GetTranslation__SWIG_0(PyObject *, PyObject *args) {
12443     PyObject *resultobj;
12444     wxString *arg1 = 0 ;
12445     wxString result;
12446     bool temp1 = false ;
12447     PyObject * obj0 = 0 ;
12448
12449     if(!PyArg_ParseTuple(args,(char *)"O:GetTranslation",&obj0)) goto fail;
12450     {
12451         arg1 = wxString_in_helper(obj0);
12452         if (arg1 == NULL) SWIG_fail;
12453         temp1 = true;
12454     }
12455     {
12456         PyThreadState* __tstate = wxPyBeginAllowThreads();
12457         result = wxGetTranslation((wxString const &)*arg1);
12458
12459         wxPyEndAllowThreads(__tstate);
12460         if (PyErr_Occurred()) SWIG_fail;
12461     }
12462     {
12463 #if wxUSE_UNICODE
12464         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12465 #else
12466         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12467 #endif
12468     }
12469     {
12470         if (temp1)
12471         delete arg1;
12472     }
12473     return resultobj;
12474     fail:
12475     {
12476         if (temp1)
12477         delete arg1;
12478     }
12479     return NULL;
12480 }
12481
12482
12483 static PyObject *_wrap_GetTranslation__SWIG_1(PyObject *, PyObject *args) {
12484     PyObject *resultobj;
12485     wxString *arg1 = 0 ;
12486     wxString *arg2 = 0 ;
12487     size_t arg3 ;
12488     wxString result;
12489     bool temp1 = false ;
12490     bool temp2 = false ;
12491     PyObject * obj0 = 0 ;
12492     PyObject * obj1 = 0 ;
12493     PyObject * obj2 = 0 ;
12494
12495     if(!PyArg_ParseTuple(args,(char *)"OOO:GetTranslation",&obj0,&obj1,&obj2)) goto fail;
12496     {
12497         arg1 = wxString_in_helper(obj0);
12498         if (arg1 == NULL) SWIG_fail;
12499         temp1 = true;
12500     }
12501     {
12502         arg2 = wxString_in_helper(obj1);
12503         if (arg2 == NULL) SWIG_fail;
12504         temp2 = true;
12505     }
12506     {
12507         arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
12508         if (SWIG_arg_fail(3)) SWIG_fail;
12509     }
12510     {
12511         PyThreadState* __tstate = wxPyBeginAllowThreads();
12512         result = wxGetTranslation((wxString const &)*arg1,(wxString const &)*arg2,arg3);
12513
12514         wxPyEndAllowThreads(__tstate);
12515         if (PyErr_Occurred()) SWIG_fail;
12516     }
12517     {
12518 #if wxUSE_UNICODE
12519         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12520 #else
12521         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12522 #endif
12523     }
12524     {
12525         if (temp1)
12526         delete arg1;
12527     }
12528     {
12529         if (temp2)
12530         delete arg2;
12531     }
12532     return resultobj;
12533     fail:
12534     {
12535         if (temp1)
12536         delete arg1;
12537     }
12538     {
12539         if (temp2)
12540         delete arg2;
12541     }
12542     return NULL;
12543 }
12544
12545
12546 static PyObject *_wrap_GetTranslation(PyObject *self, PyObject *args) {
12547     int argc;
12548     PyObject *argv[4];
12549     int ii;
12550
12551     argc = PyObject_Length(args);
12552     for (ii = 0; (ii < argc) && (ii < 3); ii++) {
12553         argv[ii] = PyTuple_GetItem(args,ii);
12554     }
12555     if (argc == 1) {
12556         int _v;
12557         {
12558             _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12559         }
12560         if (_v) {
12561             return _wrap_GetTranslation__SWIG_0(self,args);
12562         }
12563     }
12564     if (argc == 3) {
12565         int _v;
12566         {
12567             _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12568         }
12569         if (_v) {
12570             {
12571                 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
12572             }
12573             if (_v) {
12574                 _v = SWIG_Check_unsigned_SS_long(argv[2]);
12575                 if (_v) {
12576                     return _wrap_GetTranslation__SWIG_1(self,args);
12577                 }
12578             }
12579         }
12580     }
12581
12582     PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GetTranslation'");
12583     return NULL;
12584 }
12585
12586
12587 static PyObject *_wrap_new_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
12588     PyObject *resultobj;
12589     wxEncodingConverter *result;
12590     char *kwnames[] = {
12591         NULL
12592     };
12593
12594     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EncodingConverter",kwnames)) goto fail;
12595     {
12596         PyThreadState* __tstate = wxPyBeginAllowThreads();
12597         result = (wxEncodingConverter *)new wxEncodingConverter();
12598
12599         wxPyEndAllowThreads(__tstate);
12600         if (PyErr_Occurred()) SWIG_fail;
12601     }
12602     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEncodingConverter, 1);
12603     return resultobj;
12604     fail:
12605     return NULL;
12606 }
12607
12608
12609 static PyObject *_wrap_delete_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
12610     PyObject *resultobj;
12611     wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12612     PyObject * obj0 = 0 ;
12613     char *kwnames[] = {
12614         (char *) "self", NULL
12615     };
12616
12617     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EncodingConverter",kwnames,&obj0)) goto fail;
12618     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12619     if (SWIG_arg_fail(1)) SWIG_fail;
12620     {
12621         PyThreadState* __tstate = wxPyBeginAllowThreads();
12622         delete arg1;
12623
12624         wxPyEndAllowThreads(__tstate);
12625         if (PyErr_Occurred()) SWIG_fail;
12626     }
12627     Py_INCREF(Py_None); resultobj = Py_None;
12628     return resultobj;
12629     fail:
12630     return NULL;
12631 }
12632
12633
12634 static PyObject *_wrap_EncodingConverter_Init(PyObject *, PyObject *args, PyObject *kwargs) {
12635     PyObject *resultobj;
12636     wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12637     wxFontEncoding arg2 ;
12638     wxFontEncoding arg3 ;
12639     int arg4 = (int) wxCONVERT_STRICT ;
12640     bool result;
12641     PyObject * obj0 = 0 ;
12642     PyObject * obj1 = 0 ;
12643     PyObject * obj2 = 0 ;
12644     PyObject * obj3 = 0 ;
12645     char *kwnames[] = {
12646         (char *) "self",(char *) "input_enc",(char *) "output_enc",(char *) "method", NULL
12647     };
12648
12649     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:EncodingConverter_Init",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12650     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12651     if (SWIG_arg_fail(1)) SWIG_fail;
12652     {
12653         arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12654         if (SWIG_arg_fail(2)) SWIG_fail;
12655     }
12656     {
12657         arg3 = (wxFontEncoding)(SWIG_As_int(obj2));
12658         if (SWIG_arg_fail(3)) SWIG_fail;
12659     }
12660     if (obj3) {
12661         {
12662             arg4 = (int)(SWIG_As_int(obj3));
12663             if (SWIG_arg_fail(4)) SWIG_fail;
12664         }
12665     }
12666     {
12667         PyThreadState* __tstate = wxPyBeginAllowThreads();
12668         result = (bool)(arg1)->Init((wxFontEncoding )arg2,(wxFontEncoding )arg3,arg4);
12669
12670         wxPyEndAllowThreads(__tstate);
12671         if (PyErr_Occurred()) SWIG_fail;
12672     }
12673     {
12674         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12675     }
12676     return resultobj;
12677     fail:
12678     return NULL;
12679 }
12680
12681
12682 static PyObject *_wrap_EncodingConverter_Convert(PyObject *, PyObject *args, PyObject *kwargs) {
12683     PyObject *resultobj;
12684     wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12685     wxString *arg2 = 0 ;
12686     wxString result;
12687     bool temp2 = false ;
12688     PyObject * obj0 = 0 ;
12689     PyObject * obj1 = 0 ;
12690     char *kwnames[] = {
12691         (char *) "self",(char *) "input", NULL
12692     };
12693
12694     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_Convert",kwnames,&obj0,&obj1)) goto fail;
12695     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12696     if (SWIG_arg_fail(1)) SWIG_fail;
12697     {
12698         arg2 = wxString_in_helper(obj1);
12699         if (arg2 == NULL) SWIG_fail;
12700         temp2 = true;
12701     }
12702     {
12703         PyThreadState* __tstate = wxPyBeginAllowThreads();
12704         result = (arg1)->Convert((wxString const &)*arg2);
12705
12706         wxPyEndAllowThreads(__tstate);
12707         if (PyErr_Occurred()) SWIG_fail;
12708     }
12709     {
12710 #if wxUSE_UNICODE
12711         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12712 #else
12713         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12714 #endif
12715     }
12716     {
12717         if (temp2)
12718         delete arg2;
12719     }
12720     return resultobj;
12721     fail:
12722     {
12723         if (temp2)
12724         delete arg2;
12725     }
12726     return NULL;
12727 }
12728
12729
12730 static PyObject *_wrap_EncodingConverter_GetPlatformEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12731     PyObject *resultobj;
12732     wxFontEncoding arg1 ;
12733     int arg2 = (int) wxPLATFORM_CURRENT ;
12734     wxFontEncodingArray result;
12735     PyObject * obj0 = 0 ;
12736     PyObject * obj1 = 0 ;
12737     char *kwnames[] = {
12738         (char *) "enc",(char *) "platform", NULL
12739     };
12740
12741     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EncodingConverter_GetPlatformEquivalents",kwnames,&obj0,&obj1)) goto fail;
12742     {
12743         arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12744         if (SWIG_arg_fail(1)) SWIG_fail;
12745     }
12746     if (obj1) {
12747         {
12748             arg2 = (int)(SWIG_As_int(obj1));
12749             if (SWIG_arg_fail(2)) SWIG_fail;
12750         }
12751     }
12752     {
12753         PyThreadState* __tstate = wxPyBeginAllowThreads();
12754         result = wxEncodingConverter::GetPlatformEquivalents((wxFontEncoding )arg1,arg2);
12755
12756         wxPyEndAllowThreads(__tstate);
12757         if (PyErr_Occurred()) SWIG_fail;
12758     }
12759     {
12760         resultobj = PyList_New(0);
12761         for (size_t i=0; i < (&result)->GetCount(); i++) {
12762             PyObject* number = PyInt_FromLong((&result)->Item(i));
12763             PyList_Append(resultobj, number);
12764             Py_DECREF(number);
12765         }
12766     }
12767     return resultobj;
12768     fail:
12769     return NULL;
12770 }
12771
12772
12773 static PyObject *_wrap_EncodingConverter_GetAllEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12774     PyObject *resultobj;
12775     wxFontEncoding arg1 ;
12776     wxFontEncodingArray result;
12777     PyObject * obj0 = 0 ;
12778     char *kwnames[] = {
12779         (char *) "enc", NULL
12780     };
12781
12782     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EncodingConverter_GetAllEquivalents",kwnames,&obj0)) goto fail;
12783     {
12784         arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12785         if (SWIG_arg_fail(1)) SWIG_fail;
12786     }
12787     {
12788         PyThreadState* __tstate = wxPyBeginAllowThreads();
12789         result = wxEncodingConverter::GetAllEquivalents((wxFontEncoding )arg1);
12790
12791         wxPyEndAllowThreads(__tstate);
12792         if (PyErr_Occurred()) SWIG_fail;
12793     }
12794     {
12795         resultobj = PyList_New(0);
12796         for (size_t i=0; i < (&result)->GetCount(); i++) {
12797             PyObject* number = PyInt_FromLong((&result)->Item(i));
12798             PyList_Append(resultobj, number);
12799             Py_DECREF(number);
12800         }
12801     }
12802     return resultobj;
12803     fail:
12804     return NULL;
12805 }
12806
12807
12808 static PyObject *_wrap_EncodingConverter_CanConvert(PyObject *, PyObject *args, PyObject *kwargs) {
12809     PyObject *resultobj;
12810     wxFontEncoding arg1 ;
12811     wxFontEncoding arg2 ;
12812     bool result;
12813     PyObject * obj0 = 0 ;
12814     PyObject * obj1 = 0 ;
12815     char *kwnames[] = {
12816         (char *) "encIn",(char *) "encOut", NULL
12817     };
12818
12819     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_CanConvert",kwnames,&obj0,&obj1)) goto fail;
12820     {
12821         arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12822         if (SWIG_arg_fail(1)) SWIG_fail;
12823     }
12824     {
12825         arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12826         if (SWIG_arg_fail(2)) SWIG_fail;
12827     }
12828     {
12829         PyThreadState* __tstate = wxPyBeginAllowThreads();
12830         result = (bool)wxEncodingConverter::CanConvert((wxFontEncoding )arg1,(wxFontEncoding )arg2);
12831
12832         wxPyEndAllowThreads(__tstate);
12833         if (PyErr_Occurred()) SWIG_fail;
12834     }
12835     {
12836         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12837     }
12838     return resultobj;
12839     fail:
12840     return NULL;
12841 }
12842
12843
12844 static PyObject * EncodingConverter_swigregister(PyObject *, PyObject *args) {
12845     PyObject *obj;
12846     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12847     SWIG_TypeClientData(SWIGTYPE_p_wxEncodingConverter, obj);
12848     Py_INCREF(obj);
12849     return Py_BuildValue((char *)"");
12850 }
12851 static PyObject *_wrap_delete_DC(PyObject *, PyObject *args, PyObject *kwargs) {
12852     PyObject *resultobj;
12853     wxDC *arg1 = (wxDC *) 0 ;
12854     PyObject * obj0 = 0 ;
12855     char *kwnames[] = {
12856         (char *) "self", NULL
12857     };
12858
12859     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DC",kwnames,&obj0)) goto fail;
12860     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12861     if (SWIG_arg_fail(1)) SWIG_fail;
12862     {
12863         PyThreadState* __tstate = wxPyBeginAllowThreads();
12864         delete arg1;
12865
12866         wxPyEndAllowThreads(__tstate);
12867         if (PyErr_Occurred()) SWIG_fail;
12868     }
12869     Py_INCREF(Py_None); resultobj = Py_None;
12870     return resultobj;
12871     fail:
12872     return NULL;
12873 }
12874
12875
12876 static PyObject *_wrap_DC_BeginDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12877     PyObject *resultobj;
12878     wxDC *arg1 = (wxDC *) 0 ;
12879     PyObject * obj0 = 0 ;
12880     char *kwnames[] = {
12881         (char *) "self", NULL
12882     };
12883
12884     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_BeginDrawing",kwnames,&obj0)) goto fail;
12885     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12886     if (SWIG_arg_fail(1)) SWIG_fail;
12887     {
12888         PyThreadState* __tstate = wxPyBeginAllowThreads();
12889         (arg1)->BeginDrawing();
12890
12891         wxPyEndAllowThreads(__tstate);
12892         if (PyErr_Occurred()) SWIG_fail;
12893     }
12894     Py_INCREF(Py_None); resultobj = Py_None;
12895     return resultobj;
12896     fail:
12897     return NULL;
12898 }
12899
12900
12901 static PyObject *_wrap_DC_EndDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12902     PyObject *resultobj;
12903     wxDC *arg1 = (wxDC *) 0 ;
12904     PyObject * obj0 = 0 ;
12905     char *kwnames[] = {
12906         (char *) "self", NULL
12907     };
12908
12909     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDrawing",kwnames,&obj0)) goto fail;
12910     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12911     if (SWIG_arg_fail(1)) SWIG_fail;
12912     {
12913         PyThreadState* __tstate = wxPyBeginAllowThreads();
12914         (arg1)->EndDrawing();
12915
12916         wxPyEndAllowThreads(__tstate);
12917         if (PyErr_Occurred()) SWIG_fail;
12918     }
12919     Py_INCREF(Py_None); resultobj = Py_None;
12920     return resultobj;
12921     fail:
12922     return NULL;
12923 }
12924
12925
12926 static PyObject *_wrap_DC_FloodFill(PyObject *, PyObject *args, PyObject *kwargs) {
12927     PyObject *resultobj;
12928     wxDC *arg1 = (wxDC *) 0 ;
12929     int arg2 ;
12930     int arg3 ;
12931     wxColour *arg4 = 0 ;
12932     int arg5 = (int) wxFLOOD_SURFACE ;
12933     bool result;
12934     wxColour temp4 ;
12935     PyObject * obj0 = 0 ;
12936     PyObject * obj1 = 0 ;
12937     PyObject * obj2 = 0 ;
12938     PyObject * obj3 = 0 ;
12939     PyObject * obj4 = 0 ;
12940     char *kwnames[] = {
12941         (char *) "self",(char *) "x",(char *) "y",(char *) "col",(char *) "style", NULL
12942     };
12943
12944     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_FloodFill",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12945     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12946     if (SWIG_arg_fail(1)) SWIG_fail;
12947     {
12948         arg2 = (int)(SWIG_As_int(obj1));
12949         if (SWIG_arg_fail(2)) SWIG_fail;
12950     }
12951     {
12952         arg3 = (int)(SWIG_As_int(obj2));
12953         if (SWIG_arg_fail(3)) SWIG_fail;
12954     }
12955     {
12956         arg4 = &temp4;
12957         if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
12958     }
12959     if (obj4) {
12960         {
12961             arg5 = (int)(SWIG_As_int(obj4));
12962             if (SWIG_arg_fail(5)) SWIG_fail;
12963         }
12964     }
12965     {
12966         PyThreadState* __tstate = wxPyBeginAllowThreads();
12967         result = (bool)(arg1)->FloodFill(arg2,arg3,(wxColour const &)*arg4,arg5);
12968
12969         wxPyEndAllowThreads(__tstate);
12970         if (PyErr_Occurred()) SWIG_fail;
12971     }
12972     {
12973         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12974     }
12975     return resultobj;
12976     fail:
12977     return NULL;
12978 }
12979
12980
12981 static PyObject *_wrap_DC_FloodFillPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12982     PyObject *resultobj;
12983     wxDC *arg1 = (wxDC *) 0 ;
12984     wxPoint *arg2 = 0 ;
12985     wxColour *arg3 = 0 ;
12986     int arg4 = (int) wxFLOOD_SURFACE ;
12987     bool result;
12988     wxPoint temp2 ;
12989     wxColour temp3 ;
12990     PyObject * obj0 = 0 ;
12991     PyObject * obj1 = 0 ;
12992     PyObject * obj2 = 0 ;
12993     PyObject * obj3 = 0 ;
12994     char *kwnames[] = {
12995         (char *) "self",(char *) "pt",(char *) "col",(char *) "style", NULL
12996     };
12997
12998     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_FloodFillPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12999     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13000     if (SWIG_arg_fail(1)) SWIG_fail;
13001     {
13002         arg2 = &temp2;
13003         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13004     }
13005     {
13006         arg3 = &temp3;
13007         if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
13008     }
13009     if (obj3) {
13010         {
13011             arg4 = (int)(SWIG_As_int(obj3));
13012             if (SWIG_arg_fail(4)) SWIG_fail;
13013         }
13014     }
13015     {
13016         PyThreadState* __tstate = wxPyBeginAllowThreads();
13017         result = (bool)(arg1)->FloodFill((wxPoint const &)*arg2,(wxColour const &)*arg3,arg4);
13018
13019         wxPyEndAllowThreads(__tstate);
13020         if (PyErr_Occurred()) SWIG_fail;
13021     }
13022     {
13023         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13024     }
13025     return resultobj;
13026     fail:
13027     return NULL;
13028 }
13029
13030
13031 static PyObject *_wrap_DC_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
13032     PyObject *resultobj;
13033     wxDC *arg1 = (wxDC *) 0 ;
13034     int arg2 ;
13035     int arg3 ;
13036     wxColour result;
13037     PyObject * obj0 = 0 ;
13038     PyObject * obj1 = 0 ;
13039     PyObject * obj2 = 0 ;
13040     char *kwnames[] = {
13041         (char *) "self",(char *) "x",(char *) "y", NULL
13042     };
13043
13044     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_GetPixel",kwnames,&obj0,&obj1,&obj2)) goto fail;
13045     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13046     if (SWIG_arg_fail(1)) SWIG_fail;
13047     {
13048         arg2 = (int)(SWIG_As_int(obj1));
13049         if (SWIG_arg_fail(2)) SWIG_fail;
13050     }
13051     {
13052         arg3 = (int)(SWIG_As_int(obj2));
13053         if (SWIG_arg_fail(3)) SWIG_fail;
13054     }
13055     {
13056         PyThreadState* __tstate = wxPyBeginAllowThreads();
13057         result = wxDC_GetPixel(arg1,arg2,arg3);
13058
13059         wxPyEndAllowThreads(__tstate);
13060         if (PyErr_Occurred()) SWIG_fail;
13061     }
13062     {
13063         wxColour * resultptr;
13064         resultptr = new wxColour((wxColour &)(result));
13065         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13066     }
13067     return resultobj;
13068     fail:
13069     return NULL;
13070 }
13071
13072
13073 static PyObject *_wrap_DC_GetPixelPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13074     PyObject *resultobj;
13075     wxDC *arg1 = (wxDC *) 0 ;
13076     wxPoint *arg2 = 0 ;
13077     wxColour result;
13078     wxPoint temp2 ;
13079     PyObject * obj0 = 0 ;
13080     PyObject * obj1 = 0 ;
13081     char *kwnames[] = {
13082         (char *) "self",(char *) "pt", NULL
13083     };
13084
13085     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPixelPoint",kwnames,&obj0,&obj1)) goto fail;
13086     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13087     if (SWIG_arg_fail(1)) SWIG_fail;
13088     {
13089         arg2 = &temp2;
13090         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13091     }
13092     {
13093         PyThreadState* __tstate = wxPyBeginAllowThreads();
13094         result = wxDC_GetPixelPoint(arg1,(wxPoint const &)*arg2);
13095
13096         wxPyEndAllowThreads(__tstate);
13097         if (PyErr_Occurred()) SWIG_fail;
13098     }
13099     {
13100         wxColour * resultptr;
13101         resultptr = new wxColour((wxColour &)(result));
13102         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13103     }
13104     return resultobj;
13105     fail:
13106     return NULL;
13107 }
13108
13109
13110 static PyObject *_wrap_DC_DrawLine(PyObject *, PyObject *args, PyObject *kwargs) {
13111     PyObject *resultobj;
13112     wxDC *arg1 = (wxDC *) 0 ;
13113     int arg2 ;
13114     int arg3 ;
13115     int arg4 ;
13116     int arg5 ;
13117     PyObject * obj0 = 0 ;
13118     PyObject * obj1 = 0 ;
13119     PyObject * obj2 = 0 ;
13120     PyObject * obj3 = 0 ;
13121     PyObject * obj4 = 0 ;
13122     char *kwnames[] = {
13123         (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2", NULL
13124     };
13125
13126     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13127     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13128     if (SWIG_arg_fail(1)) SWIG_fail;
13129     {
13130         arg2 = (int)(SWIG_As_int(obj1));
13131         if (SWIG_arg_fail(2)) SWIG_fail;
13132     }
13133     {
13134         arg3 = (int)(SWIG_As_int(obj2));
13135         if (SWIG_arg_fail(3)) SWIG_fail;
13136     }
13137     {
13138         arg4 = (int)(SWIG_As_int(obj3));
13139         if (SWIG_arg_fail(4)) SWIG_fail;
13140     }
13141     {
13142         arg5 = (int)(SWIG_As_int(obj4));
13143         if (SWIG_arg_fail(5)) SWIG_fail;
13144     }
13145     {
13146         PyThreadState* __tstate = wxPyBeginAllowThreads();
13147         (arg1)->DrawLine(arg2,arg3,arg4,arg5);
13148
13149         wxPyEndAllowThreads(__tstate);
13150         if (PyErr_Occurred()) SWIG_fail;
13151     }
13152     Py_INCREF(Py_None); resultobj = Py_None;
13153     return resultobj;
13154     fail:
13155     return NULL;
13156 }
13157
13158
13159 static PyObject *_wrap_DC_DrawLinePoint(PyObject *, PyObject *args, PyObject *kwargs) {
13160     PyObject *resultobj;
13161     wxDC *arg1 = (wxDC *) 0 ;
13162     wxPoint *arg2 = 0 ;
13163     wxPoint *arg3 = 0 ;
13164     wxPoint temp2 ;
13165     wxPoint temp3 ;
13166     PyObject * obj0 = 0 ;
13167     PyObject * obj1 = 0 ;
13168     PyObject * obj2 = 0 ;
13169     char *kwnames[] = {
13170         (char *) "self",(char *) "pt1",(char *) "pt2", NULL
13171     };
13172
13173     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawLinePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13174     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13175     if (SWIG_arg_fail(1)) SWIG_fail;
13176     {
13177         arg2 = &temp2;
13178         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13179     }
13180     {
13181         arg3 = &temp3;
13182         if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13183     }
13184     {
13185         PyThreadState* __tstate = wxPyBeginAllowThreads();
13186         (arg1)->DrawLine((wxPoint const &)*arg2,(wxPoint const &)*arg3);
13187
13188         wxPyEndAllowThreads(__tstate);
13189         if (PyErr_Occurred()) SWIG_fail;
13190     }
13191     Py_INCREF(Py_None); resultobj = Py_None;
13192     return resultobj;
13193     fail:
13194     return NULL;
13195 }
13196
13197
13198 static PyObject *_wrap_DC_CrossHair(PyObject *, PyObject *args, PyObject *kwargs) {
13199     PyObject *resultobj;
13200     wxDC *arg1 = (wxDC *) 0 ;
13201     int arg2 ;
13202     int arg3 ;
13203     PyObject * obj0 = 0 ;
13204     PyObject * obj1 = 0 ;
13205     PyObject * obj2 = 0 ;
13206     char *kwnames[] = {
13207         (char *) "self",(char *) "x",(char *) "y", NULL
13208     };
13209
13210     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CrossHair",kwnames,&obj0,&obj1,&obj2)) goto fail;
13211     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13212     if (SWIG_arg_fail(1)) SWIG_fail;
13213     {
13214         arg2 = (int)(SWIG_As_int(obj1));
13215         if (SWIG_arg_fail(2)) SWIG_fail;
13216     }
13217     {
13218         arg3 = (int)(SWIG_As_int(obj2));
13219         if (SWIG_arg_fail(3)) SWIG_fail;
13220     }
13221     {
13222         PyThreadState* __tstate = wxPyBeginAllowThreads();
13223         (arg1)->CrossHair(arg2,arg3);
13224
13225         wxPyEndAllowThreads(__tstate);
13226         if (PyErr_Occurred()) SWIG_fail;
13227     }
13228     Py_INCREF(Py_None); resultobj = Py_None;
13229     return resultobj;
13230     fail:
13231     return NULL;
13232 }
13233
13234
13235 static PyObject *_wrap_DC_CrossHairPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13236     PyObject *resultobj;
13237     wxDC *arg1 = (wxDC *) 0 ;
13238     wxPoint *arg2 = 0 ;
13239     wxPoint temp2 ;
13240     PyObject * obj0 = 0 ;
13241     PyObject * obj1 = 0 ;
13242     char *kwnames[] = {
13243         (char *) "self",(char *) "pt", NULL
13244     };
13245
13246     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CrossHairPoint",kwnames,&obj0,&obj1)) goto fail;
13247     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13248     if (SWIG_arg_fail(1)) SWIG_fail;
13249     {
13250         arg2 = &temp2;
13251         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13252     }
13253     {
13254         PyThreadState* __tstate = wxPyBeginAllowThreads();
13255         (arg1)->CrossHair((wxPoint const &)*arg2);
13256
13257         wxPyEndAllowThreads(__tstate);
13258         if (PyErr_Occurred()) SWIG_fail;
13259     }
13260     Py_INCREF(Py_None); resultobj = Py_None;
13261     return resultobj;
13262     fail:
13263     return NULL;
13264 }
13265
13266
13267 static PyObject *_wrap_DC_DrawArc(PyObject *, PyObject *args, PyObject *kwargs) {
13268     PyObject *resultobj;
13269     wxDC *arg1 = (wxDC *) 0 ;
13270     int arg2 ;
13271     int arg3 ;
13272     int arg4 ;
13273     int arg5 ;
13274     int arg6 ;
13275     int arg7 ;
13276     PyObject * obj0 = 0 ;
13277     PyObject * obj1 = 0 ;
13278     PyObject * obj2 = 0 ;
13279     PyObject * obj3 = 0 ;
13280     PyObject * obj4 = 0 ;
13281     PyObject * obj5 = 0 ;
13282     PyObject * obj6 = 0 ;
13283     char *kwnames[] = {
13284         (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2",(char *) "xc",(char *) "yc", NULL
13285     };
13286
13287     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13288     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13289     if (SWIG_arg_fail(1)) SWIG_fail;
13290     {
13291         arg2 = (int)(SWIG_As_int(obj1));
13292         if (SWIG_arg_fail(2)) SWIG_fail;
13293     }
13294     {
13295         arg3 = (int)(SWIG_As_int(obj2));
13296         if (SWIG_arg_fail(3)) SWIG_fail;
13297     }
13298     {
13299         arg4 = (int)(SWIG_As_int(obj3));
13300         if (SWIG_arg_fail(4)) SWIG_fail;
13301     }
13302     {
13303         arg5 = (int)(SWIG_As_int(obj4));
13304         if (SWIG_arg_fail(5)) SWIG_fail;
13305     }
13306     {
13307         arg6 = (int)(SWIG_As_int(obj5));
13308         if (SWIG_arg_fail(6)) SWIG_fail;
13309     }
13310     {
13311         arg7 = (int)(SWIG_As_int(obj6));
13312         if (SWIG_arg_fail(7)) SWIG_fail;
13313     }
13314     {
13315         PyThreadState* __tstate = wxPyBeginAllowThreads();
13316         (arg1)->DrawArc(arg2,arg3,arg4,arg5,arg6,arg7);
13317
13318         wxPyEndAllowThreads(__tstate);
13319         if (PyErr_Occurred()) SWIG_fail;
13320     }
13321     Py_INCREF(Py_None); resultobj = Py_None;
13322     return resultobj;
13323     fail:
13324     return NULL;
13325 }
13326
13327
13328 static PyObject *_wrap_DC_DrawArcPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13329     PyObject *resultobj;
13330     wxDC *arg1 = (wxDC *) 0 ;
13331     wxPoint *arg2 = 0 ;
13332     wxPoint *arg3 = 0 ;
13333     wxPoint *arg4 = 0 ;
13334     wxPoint temp2 ;
13335     wxPoint temp3 ;
13336     wxPoint temp4 ;
13337     PyObject * obj0 = 0 ;
13338     PyObject * obj1 = 0 ;
13339     PyObject * obj2 = 0 ;
13340     PyObject * obj3 = 0 ;
13341     char *kwnames[] = {
13342         (char *) "self",(char *) "pt1",(char *) "pt2",(char *) "center", NULL
13343     };
13344
13345     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawArcPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13346     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13347     if (SWIG_arg_fail(1)) SWIG_fail;
13348     {
13349         arg2 = &temp2;
13350         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13351     }
13352     {
13353         arg3 = &temp3;
13354         if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13355     }
13356     {
13357         arg4 = &temp4;
13358         if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
13359     }
13360     {
13361         PyThreadState* __tstate = wxPyBeginAllowThreads();
13362         (arg1)->DrawArc((wxPoint const &)*arg2,(wxPoint const &)*arg3,(wxPoint const &)*arg4);
13363
13364         wxPyEndAllowThreads(__tstate);
13365         if (PyErr_Occurred()) SWIG_fail;
13366     }
13367     Py_INCREF(Py_None); resultobj = Py_None;
13368     return resultobj;
13369     fail:
13370     return NULL;
13371 }
13372
13373
13374 static PyObject *_wrap_DC_DrawCheckMark(PyObject *, PyObject *args, PyObject *kwargs) {
13375     PyObject *resultobj;
13376     wxDC *arg1 = (wxDC *) 0 ;
13377     int arg2 ;
13378     int arg3 ;
13379     int arg4 ;
13380     int arg5 ;
13381     PyObject * obj0 = 0 ;
13382     PyObject * obj1 = 0 ;
13383     PyObject * obj2 = 0 ;
13384     PyObject * obj3 = 0 ;
13385     PyObject * obj4 = 0 ;
13386     char *kwnames[] = {
13387         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13388     };
13389
13390     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawCheckMark",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13391     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13392     if (SWIG_arg_fail(1)) SWIG_fail;
13393     {
13394         arg2 = (int)(SWIG_As_int(obj1));
13395         if (SWIG_arg_fail(2)) SWIG_fail;
13396     }
13397     {
13398         arg3 = (int)(SWIG_As_int(obj2));
13399         if (SWIG_arg_fail(3)) SWIG_fail;
13400     }
13401     {
13402         arg4 = (int)(SWIG_As_int(obj3));
13403         if (SWIG_arg_fail(4)) SWIG_fail;
13404     }
13405     {
13406         arg5 = (int)(SWIG_As_int(obj4));
13407         if (SWIG_arg_fail(5)) SWIG_fail;
13408     }
13409     {
13410         PyThreadState* __tstate = wxPyBeginAllowThreads();
13411         (arg1)->DrawCheckMark(arg2,arg3,arg4,arg5);
13412
13413         wxPyEndAllowThreads(__tstate);
13414         if (PyErr_Occurred()) SWIG_fail;
13415     }
13416     Py_INCREF(Py_None); resultobj = Py_None;
13417     return resultobj;
13418     fail:
13419     return NULL;
13420 }
13421
13422
13423 static PyObject *_wrap_DC_DrawCheckMarkRect(PyObject *, PyObject *args, PyObject *kwargs) {
13424     PyObject *resultobj;
13425     wxDC *arg1 = (wxDC *) 0 ;
13426     wxRect *arg2 = 0 ;
13427     wxRect temp2 ;
13428     PyObject * obj0 = 0 ;
13429     PyObject * obj1 = 0 ;
13430     char *kwnames[] = {
13431         (char *) "self",(char *) "rect", NULL
13432     };
13433
13434     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawCheckMarkRect",kwnames,&obj0,&obj1)) goto fail;
13435     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13436     if (SWIG_arg_fail(1)) SWIG_fail;
13437     {
13438         arg2 = &temp2;
13439         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13440     }
13441     {
13442         PyThreadState* __tstate = wxPyBeginAllowThreads();
13443         (arg1)->DrawCheckMark((wxRect const &)*arg2);
13444
13445         wxPyEndAllowThreads(__tstate);
13446         if (PyErr_Occurred()) SWIG_fail;
13447     }
13448     Py_INCREF(Py_None); resultobj = Py_None;
13449     return resultobj;
13450     fail:
13451     return NULL;
13452 }
13453
13454
13455 static PyObject *_wrap_DC_DrawEllipticArc(PyObject *, PyObject *args, PyObject *kwargs) {
13456     PyObject *resultobj;
13457     wxDC *arg1 = (wxDC *) 0 ;
13458     int arg2 ;
13459     int arg3 ;
13460     int arg4 ;
13461     int arg5 ;
13462     double arg6 ;
13463     double arg7 ;
13464     PyObject * obj0 = 0 ;
13465     PyObject * obj1 = 0 ;
13466     PyObject * obj2 = 0 ;
13467     PyObject * obj3 = 0 ;
13468     PyObject * obj4 = 0 ;
13469     PyObject * obj5 = 0 ;
13470     PyObject * obj6 = 0 ;
13471     char *kwnames[] = {
13472         (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h",(char *) "start",(char *) "end", NULL
13473     };
13474
13475     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawEllipticArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13476     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13477     if (SWIG_arg_fail(1)) SWIG_fail;
13478     {
13479         arg2 = (int)(SWIG_As_int(obj1));
13480         if (SWIG_arg_fail(2)) SWIG_fail;
13481     }
13482     {
13483         arg3 = (int)(SWIG_As_int(obj2));
13484         if (SWIG_arg_fail(3)) SWIG_fail;
13485     }
13486     {
13487         arg4 = (int)(SWIG_As_int(obj3));
13488         if (SWIG_arg_fail(4)) SWIG_fail;
13489     }
13490     {
13491         arg5 = (int)(SWIG_As_int(obj4));
13492         if (SWIG_arg_fail(5)) SWIG_fail;
13493     }
13494     {
13495         arg6 = (double)(SWIG_As_double(obj5));
13496         if (SWIG_arg_fail(6)) SWIG_fail;
13497     }
13498     {
13499         arg7 = (double)(SWIG_As_double(obj6));
13500         if (SWIG_arg_fail(7)) SWIG_fail;
13501     }
13502     {
13503         PyThreadState* __tstate = wxPyBeginAllowThreads();
13504         (arg1)->DrawEllipticArc(arg2,arg3,arg4,arg5,arg6,arg7);
13505
13506         wxPyEndAllowThreads(__tstate);
13507         if (PyErr_Occurred()) SWIG_fail;
13508     }
13509     Py_INCREF(Py_None); resultobj = Py_None;
13510     return resultobj;
13511     fail:
13512     return NULL;
13513 }
13514
13515
13516 static PyObject *_wrap_DC_DrawEllipticArcPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13517     PyObject *resultobj;
13518     wxDC *arg1 = (wxDC *) 0 ;
13519     wxPoint *arg2 = 0 ;
13520     wxSize *arg3 = 0 ;
13521     double arg4 ;
13522     double arg5 ;
13523     wxPoint temp2 ;
13524     wxSize temp3 ;
13525     PyObject * obj0 = 0 ;
13526     PyObject * obj1 = 0 ;
13527     PyObject * obj2 = 0 ;
13528     PyObject * obj3 = 0 ;
13529     PyObject * obj4 = 0 ;
13530     char *kwnames[] = {
13531         (char *) "self",(char *) "pt",(char *) "sz",(char *) "start",(char *) "end", NULL
13532     };
13533
13534     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipticArcPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13535     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13536     if (SWIG_arg_fail(1)) SWIG_fail;
13537     {
13538         arg2 = &temp2;
13539         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13540     }
13541     {
13542         arg3 = &temp3;
13543         if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13544     }
13545     {
13546         arg4 = (double)(SWIG_As_double(obj3));
13547         if (SWIG_arg_fail(4)) SWIG_fail;
13548     }
13549     {
13550         arg5 = (double)(SWIG_As_double(obj4));
13551         if (SWIG_arg_fail(5)) SWIG_fail;
13552     }
13553     {
13554         PyThreadState* __tstate = wxPyBeginAllowThreads();
13555         (arg1)->DrawEllipticArc((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,arg5);
13556
13557         wxPyEndAllowThreads(__tstate);
13558         if (PyErr_Occurred()) SWIG_fail;
13559     }
13560     Py_INCREF(Py_None); resultobj = Py_None;
13561     return resultobj;
13562     fail:
13563     return NULL;
13564 }
13565
13566
13567 static PyObject *_wrap_DC_DrawPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13568     PyObject *resultobj;
13569     wxDC *arg1 = (wxDC *) 0 ;
13570     int arg2 ;
13571     int arg3 ;
13572     PyObject * obj0 = 0 ;
13573     PyObject * obj1 = 0 ;
13574     PyObject * obj2 = 0 ;
13575     char *kwnames[] = {
13576         (char *) "self",(char *) "x",(char *) "y", NULL
13577     };
13578
13579     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13580     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13581     if (SWIG_arg_fail(1)) SWIG_fail;
13582     {
13583         arg2 = (int)(SWIG_As_int(obj1));
13584         if (SWIG_arg_fail(2)) SWIG_fail;
13585     }
13586     {
13587         arg3 = (int)(SWIG_As_int(obj2));
13588         if (SWIG_arg_fail(3)) SWIG_fail;
13589     }
13590     {
13591         PyThreadState* __tstate = wxPyBeginAllowThreads();
13592         (arg1)->DrawPoint(arg2,arg3);
13593
13594         wxPyEndAllowThreads(__tstate);
13595         if (PyErr_Occurred()) SWIG_fail;
13596     }
13597     Py_INCREF(Py_None); resultobj = Py_None;
13598     return resultobj;
13599     fail:
13600     return NULL;
13601 }
13602
13603
13604 static PyObject *_wrap_DC_DrawPointPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13605     PyObject *resultobj;
13606     wxDC *arg1 = (wxDC *) 0 ;
13607     wxPoint *arg2 = 0 ;
13608     wxPoint temp2 ;
13609     PyObject * obj0 = 0 ;
13610     PyObject * obj1 = 0 ;
13611     char *kwnames[] = {
13612         (char *) "self",(char *) "pt", NULL
13613     };
13614
13615     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawPointPoint",kwnames,&obj0,&obj1)) goto fail;
13616     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13617     if (SWIG_arg_fail(1)) SWIG_fail;
13618     {
13619         arg2 = &temp2;
13620         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13621     }
13622     {
13623         PyThreadState* __tstate = wxPyBeginAllowThreads();
13624         (arg1)->DrawPoint((wxPoint const &)*arg2);
13625
13626         wxPyEndAllowThreads(__tstate);
13627         if (PyErr_Occurred()) SWIG_fail;
13628     }
13629     Py_INCREF(Py_None); resultobj = Py_None;
13630     return resultobj;
13631     fail:
13632     return NULL;
13633 }
13634
13635
13636 static PyObject *_wrap_DC_DrawRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13637     PyObject *resultobj;
13638     wxDC *arg1 = (wxDC *) 0 ;
13639     int arg2 ;
13640     int arg3 ;
13641     int arg4 ;
13642     int arg5 ;
13643     PyObject * obj0 = 0 ;
13644     PyObject * obj1 = 0 ;
13645     PyObject * obj2 = 0 ;
13646     PyObject * obj3 = 0 ;
13647     PyObject * obj4 = 0 ;
13648     char *kwnames[] = {
13649         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13650     };
13651
13652     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13653     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13654     if (SWIG_arg_fail(1)) SWIG_fail;
13655     {
13656         arg2 = (int)(SWIG_As_int(obj1));
13657         if (SWIG_arg_fail(2)) SWIG_fail;
13658     }
13659     {
13660         arg3 = (int)(SWIG_As_int(obj2));
13661         if (SWIG_arg_fail(3)) SWIG_fail;
13662     }
13663     {
13664         arg4 = (int)(SWIG_As_int(obj3));
13665         if (SWIG_arg_fail(4)) SWIG_fail;
13666     }
13667     {
13668         arg5 = (int)(SWIG_As_int(obj4));
13669         if (SWIG_arg_fail(5)) SWIG_fail;
13670     }
13671     {
13672         PyThreadState* __tstate = wxPyBeginAllowThreads();
13673         (arg1)->DrawRectangle(arg2,arg3,arg4,arg5);
13674
13675         wxPyEndAllowThreads(__tstate);
13676         if (PyErr_Occurred()) SWIG_fail;
13677     }
13678     Py_INCREF(Py_None); resultobj = Py_None;
13679     return resultobj;
13680     fail:
13681     return NULL;
13682 }
13683
13684
13685 static PyObject *_wrap_DC_DrawRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13686     PyObject *resultobj;
13687     wxDC *arg1 = (wxDC *) 0 ;
13688     wxRect *arg2 = 0 ;
13689     wxRect temp2 ;
13690     PyObject * obj0 = 0 ;
13691     PyObject * obj1 = 0 ;
13692     char *kwnames[] = {
13693         (char *) "self",(char *) "rect", NULL
13694     };
13695
13696     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawRectangleRect",kwnames,&obj0,&obj1)) goto fail;
13697     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13698     if (SWIG_arg_fail(1)) SWIG_fail;
13699     {
13700         arg2 = &temp2;
13701         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13702     }
13703     {
13704         PyThreadState* __tstate = wxPyBeginAllowThreads();
13705         (arg1)->DrawRectangle((wxRect const &)*arg2);
13706
13707         wxPyEndAllowThreads(__tstate);
13708         if (PyErr_Occurred()) SWIG_fail;
13709     }
13710     Py_INCREF(Py_None); resultobj = Py_None;
13711     return resultobj;
13712     fail:
13713     return NULL;
13714 }
13715
13716
13717 static PyObject *_wrap_DC_DrawRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13718     PyObject *resultobj;
13719     wxDC *arg1 = (wxDC *) 0 ;
13720     wxPoint *arg2 = 0 ;
13721     wxSize *arg3 = 0 ;
13722     wxPoint temp2 ;
13723     wxSize temp3 ;
13724     PyObject * obj0 = 0 ;
13725     PyObject * obj1 = 0 ;
13726     PyObject * obj2 = 0 ;
13727     char *kwnames[] = {
13728         (char *) "self",(char *) "pt",(char *) "sz", NULL
13729     };
13730
13731     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRectanglePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13732     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13733     if (SWIG_arg_fail(1)) SWIG_fail;
13734     {
13735         arg2 = &temp2;
13736         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13737     }
13738     {
13739         arg3 = &temp3;
13740         if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13741     }
13742     {
13743         PyThreadState* __tstate = wxPyBeginAllowThreads();
13744         (arg1)->DrawRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3);
13745
13746         wxPyEndAllowThreads(__tstate);
13747         if (PyErr_Occurred()) SWIG_fail;
13748     }
13749     Py_INCREF(Py_None); resultobj = Py_None;
13750     return resultobj;
13751     fail:
13752     return NULL;
13753 }
13754
13755
13756 static PyObject *_wrap_DC_DrawRoundedRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13757     PyObject *resultobj;
13758     wxDC *arg1 = (wxDC *) 0 ;
13759     int arg2 ;
13760     int arg3 ;
13761     int arg4 ;
13762     int arg5 ;
13763     double arg6 ;
13764     PyObject * obj0 = 0 ;
13765     PyObject * obj1 = 0 ;
13766     PyObject * obj2 = 0 ;
13767     PyObject * obj3 = 0 ;
13768     PyObject * obj4 = 0 ;
13769     PyObject * obj5 = 0 ;
13770     char *kwnames[] = {
13771         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "radius", NULL
13772     };
13773
13774     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:DC_DrawRoundedRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
13775     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13776     if (SWIG_arg_fail(1)) SWIG_fail;
13777     {
13778         arg2 = (int)(SWIG_As_int(obj1));
13779         if (SWIG_arg_fail(2)) SWIG_fail;
13780     }
13781     {
13782         arg3 = (int)(SWIG_As_int(obj2));
13783         if (SWIG_arg_fail(3)) SWIG_fail;
13784     }
13785     {
13786         arg4 = (int)(SWIG_As_int(obj3));
13787         if (SWIG_arg_fail(4)) SWIG_fail;
13788     }
13789     {
13790         arg5 = (int)(SWIG_As_int(obj4));
13791         if (SWIG_arg_fail(5)) SWIG_fail;
13792     }
13793     {
13794         arg6 = (double)(SWIG_As_double(obj5));
13795         if (SWIG_arg_fail(6)) SWIG_fail;
13796     }
13797     {
13798         PyThreadState* __tstate = wxPyBeginAllowThreads();
13799         (arg1)->DrawRoundedRectangle(arg2,arg3,arg4,arg5,arg6);
13800
13801         wxPyEndAllowThreads(__tstate);
13802         if (PyErr_Occurred()) SWIG_fail;
13803     }
13804     Py_INCREF(Py_None); resultobj = Py_None;
13805     return resultobj;
13806     fail:
13807     return NULL;
13808 }
13809
13810
13811 static PyObject *_wrap_DC_DrawRoundedRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13812     PyObject *resultobj;
13813     wxDC *arg1 = (wxDC *) 0 ;
13814     wxRect *arg2 = 0 ;
13815     double arg3 ;
13816     wxRect temp2 ;
13817     PyObject * obj0 = 0 ;
13818     PyObject * obj1 = 0 ;
13819     PyObject * obj2 = 0 ;
13820     char *kwnames[] = {
13821         (char *) "self",(char *) "r",(char *) "radius", NULL
13822     };
13823
13824     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRoundedRectangleRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
13825     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13826     if (SWIG_arg_fail(1)) SWIG_fail;
13827     {
13828         arg2 = &temp2;
13829         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13830     }
13831     {
13832         arg3 = (double)(SWIG_As_double(obj2));
13833         if (SWIG_arg_fail(3)) SWIG_fail;
13834     }
13835     {
13836         PyThreadState* __tstate = wxPyBeginAllowThreads();
13837         (arg1)->DrawRoundedRectangle((wxRect const &)*arg2,arg3);
13838
13839         wxPyEndAllowThreads(__tstate);
13840         if (PyErr_Occurred()) SWIG_fail;
13841     }
13842     Py_INCREF(Py_None); resultobj = Py_None;
13843     return resultobj;
13844     fail:
13845     return NULL;
13846 }
13847
13848
13849 static PyObject *_wrap_DC_DrawRoundedRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13850     PyObject *resultobj;
13851     wxDC *arg1 = (wxDC *) 0 ;
13852     wxPoint *arg2 = 0 ;
13853     wxSize *arg3 = 0 ;
13854     double arg4 ;
13855     wxPoint temp2 ;
13856     wxSize temp3 ;
13857     PyObject * obj0 = 0 ;
13858     PyObject * obj1 = 0 ;
13859     PyObject * obj2 = 0 ;
13860     PyObject * obj3 = 0 ;
13861     char *kwnames[] = {
13862         (char *) "self",(char *) "pt",(char *) "sz",(char *) "radius", NULL
13863     };
13864
13865     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRoundedRectanglePointSize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13866     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13867     if (SWIG_arg_fail(1)) SWIG_fail;
13868     {
13869         arg2 = &temp2;
13870         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13871     }
13872     {
13873         arg3 = &temp3;
13874         if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13875     }
13876     {
13877         arg4 = (double)(SWIG_As_double(obj3));
13878         if (SWIG_arg_fail(4)) SWIG_fail;
13879     }
13880     {
13881         PyThreadState* __tstate = wxPyBeginAllowThreads();
13882         (arg1)->DrawRoundedRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4);
13883
13884         wxPyEndAllowThreads(__tstate);
13885         if (PyErr_Occurred()) SWIG_fail;
13886     }
13887     Py_INCREF(Py_None); resultobj = Py_None;
13888     return resultobj;
13889     fail:
13890     return NULL;
13891 }
13892
13893
13894 static PyObject *_wrap_DC_DrawCircle(PyObject *, PyObject *args, PyObject *kwargs) {
13895     PyObject *resultobj;
13896     wxDC *arg1 = (wxDC *) 0 ;
13897     int arg2 ;
13898     int arg3 ;
13899     int arg4 ;
13900     PyObject * obj0 = 0 ;
13901     PyObject * obj1 = 0 ;
13902     PyObject * obj2 = 0 ;
13903     PyObject * obj3 = 0 ;
13904     char *kwnames[] = {
13905         (char *) "self",(char *) "x",(char *) "y",(char *) "radius", NULL
13906     };
13907
13908     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawCircle",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13909     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13910     if (SWIG_arg_fail(1)) SWIG_fail;
13911     {
13912         arg2 = (int)(SWIG_As_int(obj1));
13913         if (SWIG_arg_fail(2)) SWIG_fail;
13914     }
13915     {
13916         arg3 = (int)(SWIG_As_int(obj2));
13917         if (SWIG_arg_fail(3)) SWIG_fail;
13918     }
13919     {
13920         arg4 = (int)(SWIG_As_int(obj3));
13921         if (SWIG_arg_fail(4)) SWIG_fail;
13922     }
13923     {
13924         PyThreadState* __tstate = wxPyBeginAllowThreads();
13925         (arg1)->DrawCircle(arg2,arg3,arg4);
13926
13927         wxPyEndAllowThreads(__tstate);
13928         if (PyErr_Occurred()) SWIG_fail;
13929     }
13930     Py_INCREF(Py_None); resultobj = Py_None;
13931     return resultobj;
13932     fail:
13933     return NULL;
13934 }
13935
13936
13937 static PyObject *_wrap_DC_DrawCirclePoint(PyObject *, PyObject *args, PyObject *kwargs) {
13938     PyObject *resultobj;
13939     wxDC *arg1 = (wxDC *) 0 ;
13940     wxPoint *arg2 = 0 ;
13941     int arg3 ;
13942     wxPoint temp2 ;
13943     PyObject * obj0 = 0 ;
13944     PyObject * obj1 = 0 ;
13945     PyObject * obj2 = 0 ;
13946     char *kwnames[] = {
13947         (char *) "self",(char *) "pt",(char *) "radius", NULL
13948     };
13949
13950     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawCirclePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13951     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13952     if (SWIG_arg_fail(1)) SWIG_fail;
13953     {
13954         arg2 = &temp2;
13955         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13956     }
13957     {
13958         arg3 = (int)(SWIG_As_int(obj2));
13959         if (SWIG_arg_fail(3)) SWIG_fail;
13960     }
13961     {
13962         PyThreadState* __tstate = wxPyBeginAllowThreads();
13963         (arg1)->DrawCircle((wxPoint const &)*arg2,arg3);
13964
13965         wxPyEndAllowThreads(__tstate);
13966         if (PyErr_Occurred()) SWIG_fail;
13967     }
13968     Py_INCREF(Py_None); resultobj = Py_None;
13969     return resultobj;
13970     fail:
13971     return NULL;
13972 }
13973
13974
13975 static PyObject *_wrap_DC_DrawEllipse(PyObject *, PyObject *args, PyObject *kwargs) {
13976     PyObject *resultobj;
13977     wxDC *arg1 = (wxDC *) 0 ;
13978     int arg2 ;
13979     int arg3 ;
13980     int arg4 ;
13981     int arg5 ;
13982     PyObject * obj0 = 0 ;
13983     PyObject * obj1 = 0 ;
13984     PyObject * obj2 = 0 ;
13985     PyObject * obj3 = 0 ;
13986     PyObject * obj4 = 0 ;
13987     char *kwnames[] = {
13988         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13989     };
13990
13991     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipse",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13992     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13993     if (SWIG_arg_fail(1)) SWIG_fail;
13994     {
13995         arg2 = (int)(SWIG_As_int(obj1));
13996         if (SWIG_arg_fail(2)) SWIG_fail;
13997     }
13998     {
13999         arg3 = (int)(SWIG_As_int(obj2));
14000         if (SWIG_arg_fail(3)) SWIG_fail;
14001     }
14002     {
14003         arg4 = (int)(SWIG_As_int(obj3));
14004         if (SWIG_arg_fail(4)) SWIG_fail;
14005     }
14006     {
14007         arg5 = (int)(SWIG_As_int(obj4));
14008         if (SWIG_arg_fail(5)) SWIG_fail;
14009     }
14010     {
14011         PyThreadState* __tstate = wxPyBeginAllowThreads();
14012         (arg1)->DrawEllipse(arg2,arg3,arg4,arg5);
14013
14014         wxPyEndAllowThreads(__tstate);
14015         if (PyErr_Occurred()) SWIG_fail;
14016     }
14017     Py_INCREF(Py_None); resultobj = Py_None;
14018     return resultobj;
14019     fail:
14020     return NULL;
14021 }
14022
14023
14024 static PyObject *_wrap_DC_DrawEllipseRect(PyObject *, PyObject *args, PyObject *kwargs) {
14025     PyObject *resultobj;
14026     wxDC *arg1 = (wxDC *) 0 ;
14027     wxRect *arg2 = 0 ;
14028     wxRect temp2 ;
14029     PyObject * obj0 = 0 ;
14030     PyObject * obj1 = 0 ;
14031     char *kwnames[] = {
14032         (char *) "self",(char *) "rect", NULL
14033     };
14034
14035     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawEllipseRect",kwnames,&obj0,&obj1)) goto fail;
14036     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14037     if (SWIG_arg_fail(1)) SWIG_fail;
14038     {
14039         arg2 = &temp2;
14040         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14041     }
14042     {
14043         PyThreadState* __tstate = wxPyBeginAllowThreads();
14044         (arg1)->DrawEllipse((wxRect const &)*arg2);
14045
14046         wxPyEndAllowThreads(__tstate);
14047         if (PyErr_Occurred()) SWIG_fail;
14048     }
14049     Py_INCREF(Py_None); resultobj = Py_None;
14050     return resultobj;
14051     fail:
14052     return NULL;
14053 }
14054
14055
14056 static PyObject *_wrap_DC_DrawEllipsePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14057     PyObject *resultobj;
14058     wxDC *arg1 = (wxDC *) 0 ;
14059     wxPoint *arg2 = 0 ;
14060     wxSize *arg3 = 0 ;
14061     wxPoint temp2 ;
14062     wxSize temp3 ;
14063     PyObject * obj0 = 0 ;
14064     PyObject * obj1 = 0 ;
14065     PyObject * obj2 = 0 ;
14066     char *kwnames[] = {
14067         (char *) "self",(char *) "pt",(char *) "sz", NULL
14068     };
14069
14070     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawEllipsePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14071     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14072     if (SWIG_arg_fail(1)) SWIG_fail;
14073     {
14074         arg2 = &temp2;
14075         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14076     }
14077     {
14078         arg3 = &temp3;
14079         if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14080     }
14081     {
14082         PyThreadState* __tstate = wxPyBeginAllowThreads();
14083         (arg1)->DrawEllipse((wxPoint const &)*arg2,(wxSize const &)*arg3);
14084
14085         wxPyEndAllowThreads(__tstate);
14086         if (PyErr_Occurred()) SWIG_fail;
14087     }
14088     Py_INCREF(Py_None); resultobj = Py_None;
14089     return resultobj;
14090     fail:
14091     return NULL;
14092 }
14093
14094
14095 static PyObject *_wrap_DC_DrawIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14096     PyObject *resultobj;
14097     wxDC *arg1 = (wxDC *) 0 ;
14098     wxIcon *arg2 = 0 ;
14099     int arg3 ;
14100     int arg4 ;
14101     PyObject * obj0 = 0 ;
14102     PyObject * obj1 = 0 ;
14103     PyObject * obj2 = 0 ;
14104     PyObject * obj3 = 0 ;
14105     char *kwnames[] = {
14106         (char *) "self",(char *) "icon",(char *) "x",(char *) "y", NULL
14107     };
14108
14109     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14110     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14111     if (SWIG_arg_fail(1)) SWIG_fail;
14112     {
14113         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
14114         if (SWIG_arg_fail(2)) SWIG_fail;
14115         if (arg2 == NULL) {
14116             SWIG_null_ref("wxIcon");
14117         }
14118         if (SWIG_arg_fail(2)) SWIG_fail;
14119     }
14120     {
14121         arg3 = (int)(SWIG_As_int(obj2));
14122         if (SWIG_arg_fail(3)) SWIG_fail;
14123     }
14124     {
14125         arg4 = (int)(SWIG_As_int(obj3));
14126         if (SWIG_arg_fail(4)) SWIG_fail;
14127     }
14128     {
14129         PyThreadState* __tstate = wxPyBeginAllowThreads();
14130         (arg1)->DrawIcon((wxIcon const &)*arg2,arg3,arg4);
14131
14132         wxPyEndAllowThreads(__tstate);
14133         if (PyErr_Occurred()) SWIG_fail;
14134     }
14135     Py_INCREF(Py_None); resultobj = Py_None;
14136     return resultobj;
14137     fail:
14138     return NULL;
14139 }
14140
14141
14142 static PyObject *_wrap_DC_DrawIconPoint(PyObject *, PyObject *args, PyObject *kwargs) {
14143     PyObject *resultobj;
14144     wxDC *arg1 = (wxDC *) 0 ;
14145     wxIcon *arg2 = 0 ;
14146     wxPoint *arg3 = 0 ;
14147     wxPoint temp3 ;
14148     PyObject * obj0 = 0 ;
14149     PyObject * obj1 = 0 ;
14150     PyObject * obj2 = 0 ;
14151     char *kwnames[] = {
14152         (char *) "self",(char *) "icon",(char *) "pt", NULL
14153     };
14154
14155     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawIconPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
14156     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14157     if (SWIG_arg_fail(1)) SWIG_fail;
14158     {
14159         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
14160         if (SWIG_arg_fail(2)) SWIG_fail;
14161         if (arg2 == NULL) {
14162             SWIG_null_ref("wxIcon");
14163         }
14164         if (SWIG_arg_fail(2)) SWIG_fail;
14165     }
14166     {
14167         arg3 = &temp3;
14168         if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14169     }
14170     {
14171         PyThreadState* __tstate = wxPyBeginAllowThreads();
14172         (arg1)->DrawIcon((wxIcon const &)*arg2,(wxPoint const &)*arg3);
14173
14174         wxPyEndAllowThreads(__tstate);
14175         if (PyErr_Occurred()) SWIG_fail;
14176     }
14177     Py_INCREF(Py_None); resultobj = Py_None;
14178     return resultobj;
14179     fail:
14180     return NULL;
14181 }
14182
14183
14184 static PyObject *_wrap_DC_DrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14185     PyObject *resultobj;
14186     wxDC *arg1 = (wxDC *) 0 ;
14187     wxBitmap *arg2 = 0 ;
14188     int arg3 ;
14189     int arg4 ;
14190     bool arg5 = (bool) false ;
14191     PyObject * obj0 = 0 ;
14192     PyObject * obj1 = 0 ;
14193     PyObject * obj2 = 0 ;
14194     PyObject * obj3 = 0 ;
14195     PyObject * obj4 = 0 ;
14196     char *kwnames[] = {
14197         (char *) "self",(char *) "bmp",(char *) "x",(char *) "y",(char *) "useMask", NULL
14198     };
14199
14200     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_DrawBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14201     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14202     if (SWIG_arg_fail(1)) SWIG_fail;
14203     {
14204         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
14205         if (SWIG_arg_fail(2)) SWIG_fail;
14206         if (arg2 == NULL) {
14207             SWIG_null_ref("wxBitmap");
14208         }
14209         if (SWIG_arg_fail(2)) SWIG_fail;
14210     }
14211     {
14212         arg3 = (int)(SWIG_As_int(obj2));
14213         if (SWIG_arg_fail(3)) SWIG_fail;
14214     }
14215     {
14216         arg4 = (int)(SWIG_As_int(obj3));
14217         if (SWIG_arg_fail(4)) SWIG_fail;
14218     }
14219     if (obj4) {
14220         {
14221             arg5 = (bool)(SWIG_As_bool(obj4));
14222             if (SWIG_arg_fail(5)) SWIG_fail;
14223         }
14224     }
14225     {
14226         PyThreadState* __tstate = wxPyBeginAllowThreads();
14227         (arg1)->DrawBitmap((wxBitmap const &)*arg2,arg3,arg4,arg5);
14228
14229         wxPyEndAllowThreads(__tstate);
14230         if (PyErr_Occurred()) SWIG_fail;
14231     }
14232     Py_INCREF(Py_None); resultobj = Py_None;
14233     return resultobj;
14234     fail:
14235     return NULL;
14236 }
14237
14238
14239 static PyObject *_wrap_DC_DrawBitmapPoint(PyObject *, PyObject *args, PyObject *kwargs) {
14240     PyObject *resultobj;
14241     wxDC *arg1 = (wxDC *) 0 ;
14242     wxBitmap *arg2 = 0 ;
14243     wxPoint *arg3 = 0 ;
14244     bool arg4 = (bool) false ;
14245     wxPoint temp3 ;
14246     PyObject * obj0 = 0 ;
14247     PyObject * obj1 = 0 ;
14248     PyObject * obj2 = 0 ;
14249     PyObject * obj3 = 0 ;
14250     char *kwnames[] = {
14251         (char *) "self",(char *) "bmp",(char *) "pt",(char *) "useMask", NULL
14252     };
14253
14254     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_DrawBitmapPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14255     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14256     if (SWIG_arg_fail(1)) SWIG_fail;
14257     {
14258         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
14259         if (SWIG_arg_fail(2)) SWIG_fail;
14260         if (arg2 == NULL) {
14261             SWIG_null_ref("wxBitmap");
14262         }
14263         if (SWIG_arg_fail(2)) SWIG_fail;
14264     }
14265     {
14266         arg3 = &temp3;
14267         if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14268     }
14269     if (obj3) {
14270         {
14271             arg4 = (bool)(SWIG_As_bool(obj3));
14272             if (SWIG_arg_fail(4)) SWIG_fail;
14273         }
14274     }
14275     {
14276         PyThreadState* __tstate = wxPyBeginAllowThreads();
14277         (arg1)->DrawBitmap((wxBitmap const &)*arg2,(wxPoint const &)*arg3,arg4);
14278
14279         wxPyEndAllowThreads(__tstate);
14280         if (PyErr_Occurred()) SWIG_fail;
14281     }
14282     Py_INCREF(Py_None); resultobj = Py_None;
14283     return resultobj;
14284     fail:
14285     return NULL;
14286 }
14287
14288
14289 static PyObject *_wrap_DC_DrawText(PyObject *, PyObject *args, PyObject *kwargs) {
14290     PyObject *resultobj;
14291     wxDC *arg1 = (wxDC *) 0 ;
14292     wxString *arg2 = 0 ;
14293     int arg3 ;
14294     int arg4 ;
14295     bool temp2 = false ;
14296     PyObject * obj0 = 0 ;
14297     PyObject * obj1 = 0 ;
14298     PyObject * obj2 = 0 ;
14299     PyObject * obj3 = 0 ;
14300     char *kwnames[] = {
14301         (char *) "self",(char *) "text",(char *) "x",(char *) "y", NULL
14302     };
14303
14304     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawText",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14305     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14306     if (SWIG_arg_fail(1)) SWIG_fail;
14307     {
14308         arg2 = wxString_in_helper(obj1);
14309         if (arg2 == NULL) SWIG_fail;
14310         temp2 = true;
14311     }
14312     {
14313         arg3 = (int)(SWIG_As_int(obj2));
14314         if (SWIG_arg_fail(3)) SWIG_fail;
14315     }
14316     {
14317         arg4 = (int)(SWIG_As_int(obj3));
14318         if (SWIG_arg_fail(4)) SWIG_fail;
14319     }
14320     {
14321         PyThreadState* __tstate = wxPyBeginAllowThreads();
14322         (arg1)->DrawText((wxString const &)*arg2,arg3,arg4);
14323
14324         wxPyEndAllowThreads(__tstate);
14325         if (PyErr_Occurred()) SWIG_fail;
14326     }
14327     Py_INCREF(Py_None); resultobj = Py_None;
14328     {
14329         if (temp2)
14330         delete arg2;
14331     }
14332     return resultobj;
14333     fail:
14334     {
14335         if (temp2)
14336         delete arg2;
14337     }
14338     return NULL;
14339 }
14340
14341
14342 static PyObject *_wrap_DC_DrawTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
14343     PyObject *resultobj;
14344     wxDC *arg1 = (wxDC *) 0 ;
14345     wxString *arg2 = 0 ;
14346     wxPoint *arg3 = 0 ;
14347     bool temp2 = false ;
14348     wxPoint temp3 ;
14349     PyObject * obj0 = 0 ;
14350     PyObject * obj1 = 0 ;
14351     PyObject * obj2 = 0 ;
14352     char *kwnames[] = {
14353         (char *) "self",(char *) "text",(char *) "pt", NULL
14354     };
14355
14356     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawTextPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
14357     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14358     if (SWIG_arg_fail(1)) SWIG_fail;
14359     {
14360         arg2 = wxString_in_helper(obj1);
14361         if (arg2 == NULL) SWIG_fail;
14362         temp2 = true;
14363     }
14364     {
14365         arg3 = &temp3;
14366         if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14367     }
14368     {
14369         PyThreadState* __tstate = wxPyBeginAllowThreads();
14370         (arg1)->DrawText((wxString const &)*arg2,(wxPoint const &)*arg3);
14371
14372         wxPyEndAllowThreads(__tstate);
14373         if (PyErr_Occurred()) SWIG_fail;
14374     }
14375     Py_INCREF(Py_None); resultobj = Py_None;
14376     {
14377         if (temp2)
14378         delete arg2;
14379     }
14380     return resultobj;
14381     fail:
14382     {
14383         if (temp2)
14384         delete arg2;
14385     }
14386     return NULL;
14387 }
14388
14389
14390 static PyObject *_wrap_DC_DrawRotatedText(PyObject *, PyObject *args, PyObject *kwargs) {
14391     PyObject *resultobj;
14392     wxDC *arg1 = (wxDC *) 0 ;
14393     wxString *arg2 = 0 ;
14394     int arg3 ;
14395     int arg4 ;
14396     double arg5 ;
14397     bool temp2 = false ;
14398     PyObject * obj0 = 0 ;
14399     PyObject * obj1 = 0 ;
14400     PyObject * obj2 = 0 ;
14401     PyObject * obj3 = 0 ;
14402     PyObject * obj4 = 0 ;
14403     char *kwnames[] = {
14404         (char *) "self",(char *) "text",(char *) "x",(char *) "y",(char *) "angle", NULL
14405     };
14406
14407     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRotatedText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14408     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14409     if (SWIG_arg_fail(1)) SWIG_fail;
14410     {
14411         arg2 = wxString_in_helper(obj1);
14412         if (arg2 == NULL) SWIG_fail;
14413         temp2 = true;
14414     }
14415     {
14416         arg3 = (int)(SWIG_As_int(obj2));
14417         if (SWIG_arg_fail(3)) SWIG_fail;
14418     }
14419     {
14420         arg4 = (int)(SWIG_As_int(obj3));
14421         if (SWIG_arg_fail(4)) SWIG_fail;
14422     }
14423     {
14424         arg5 = (double)(SWIG_As_double(obj4));
14425         if (SWIG_arg_fail(5)) SWIG_fail;
14426     }
14427     {
14428         PyThreadState* __tstate = wxPyBeginAllowThreads();
14429         (arg1)->DrawRotatedText((wxString const &)*arg2,arg3,arg4,arg5);
14430
14431         wxPyEndAllowThreads(__tstate);
14432         if (PyErr_Occurred()) SWIG_fail;
14433     }
14434     Py_INCREF(Py_None); resultobj = Py_None;
14435     {
14436         if (temp2)
14437         delete arg2;
14438     }
14439     return resultobj;
14440     fail:
14441     {
14442         if (temp2)
14443         delete arg2;
14444     }
14445     return NULL;
14446 }
14447
14448
14449 static PyObject *_wrap_DC_DrawRotatedTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
14450     PyObject *resultobj;
14451     wxDC *arg1 = (wxDC *) 0 ;
14452     wxString *arg2 = 0 ;
14453     wxPoint *arg3 = 0 ;
14454     double arg4 ;
14455     bool temp2 = false ;
14456     wxPoint temp3 ;
14457     PyObject * obj0 = 0 ;
14458     PyObject * obj1 = 0 ;
14459     PyObject * obj2 = 0 ;
14460     PyObject * obj3 = 0 ;
14461     char *kwnames[] = {
14462         (char *) "self",(char *) "text",(char *) "pt",(char *) "angle", NULL
14463     };
14464
14465     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRotatedTextPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14466     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14467     if (SWIG_arg_fail(1)) SWIG_fail;
14468     {
14469         arg2 = wxString_in_helper(obj1);
14470         if (arg2 == NULL) SWIG_fail;
14471         temp2 = true;
14472     }
14473     {
14474         arg3 = &temp3;
14475         if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14476     }
14477     {
14478         arg4 = (double)(SWIG_As_double(obj3));
14479         if (SWIG_arg_fail(4)) SWIG_fail;
14480     }
14481     {
14482         PyThreadState* __tstate = wxPyBeginAllowThreads();
14483         (arg1)->DrawRotatedText((wxString const &)*arg2,(wxPoint const &)*arg3,arg4);
14484
14485         wxPyEndAllowThreads(__tstate);
14486         if (PyErr_Occurred()) SWIG_fail;
14487     }
14488     Py_INCREF(Py_None); resultobj = Py_None;
14489     {
14490         if (temp2)
14491         delete arg2;
14492     }
14493     return resultobj;
14494     fail:
14495     {
14496         if (temp2)
14497         delete arg2;
14498     }
14499     return NULL;
14500 }
14501
14502
14503 static PyObject *_wrap_DC_Blit(PyObject *, PyObject *args, PyObject *kwargs) {
14504     PyObject *resultobj;
14505     wxDC *arg1 = (wxDC *) 0 ;
14506     int arg2 ;
14507     int arg3 ;
14508     int arg4 ;
14509     int arg5 ;
14510     wxDC *arg6 = (wxDC *) 0 ;
14511     int arg7 ;
14512     int arg8 ;
14513     int arg9 = (int) wxCOPY ;
14514     bool arg10 = (bool) false ;
14515     int arg11 = (int) -1 ;
14516     int arg12 = (int) -1 ;
14517     bool result;
14518     PyObject * obj0 = 0 ;
14519     PyObject * obj1 = 0 ;
14520     PyObject * obj2 = 0 ;
14521     PyObject * obj3 = 0 ;
14522     PyObject * obj4 = 0 ;
14523     PyObject * obj5 = 0 ;
14524     PyObject * obj6 = 0 ;
14525     PyObject * obj7 = 0 ;
14526     PyObject * obj8 = 0 ;
14527     PyObject * obj9 = 0 ;
14528     PyObject * obj10 = 0 ;
14529     PyObject * obj11 = 0 ;
14530     char *kwnames[] = {
14531         (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
14532     };
14533
14534     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;
14535     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14536     if (SWIG_arg_fail(1)) SWIG_fail;
14537     {
14538         arg2 = (int)(SWIG_As_int(obj1));
14539         if (SWIG_arg_fail(2)) SWIG_fail;
14540     }
14541     {
14542         arg3 = (int)(SWIG_As_int(obj2));
14543         if (SWIG_arg_fail(3)) SWIG_fail;
14544     }
14545     {
14546         arg4 = (int)(SWIG_As_int(obj3));
14547         if (SWIG_arg_fail(4)) SWIG_fail;
14548     }
14549     {
14550         arg5 = (int)(SWIG_As_int(obj4));
14551         if (SWIG_arg_fail(5)) SWIG_fail;
14552     }
14553     SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14554     if (SWIG_arg_fail(6)) SWIG_fail;
14555     {
14556         arg7 = (int)(SWIG_As_int(obj6));
14557         if (SWIG_arg_fail(7)) SWIG_fail;
14558     }
14559     {
14560         arg8 = (int)(SWIG_As_int(obj7));
14561         if (SWIG_arg_fail(8)) SWIG_fail;
14562     }
14563     if (obj8) {
14564         {
14565             arg9 = (int)(SWIG_As_int(obj8));
14566             if (SWIG_arg_fail(9)) SWIG_fail;
14567         }
14568     }
14569     if (obj9) {
14570         {
14571             arg10 = (bool)(SWIG_As_bool(obj9));
14572             if (SWIG_arg_fail(10)) SWIG_fail;
14573         }
14574     }
14575     if (obj10) {
14576         {
14577             arg11 = (int)(SWIG_As_int(obj10));
14578             if (SWIG_arg_fail(11)) SWIG_fail;
14579         }
14580     }
14581     if (obj11) {
14582         {
14583             arg12 = (int)(SWIG_As_int(obj11));
14584             if (SWIG_arg_fail(12)) SWIG_fail;
14585         }
14586     }
14587     {
14588         PyThreadState* __tstate = wxPyBeginAllowThreads();
14589         result = (bool)(arg1)->Blit(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
14590
14591         wxPyEndAllowThreads(__tstate);
14592         if (PyErr_Occurred()) SWIG_fail;
14593     }
14594     {
14595         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14596     }
14597     return resultobj;
14598     fail:
14599     return NULL;
14600 }
14601
14602
14603 static PyObject *_wrap_DC_BlitPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14604     PyObject *resultobj;
14605     wxDC *arg1 = (wxDC *) 0 ;
14606     wxPoint *arg2 = 0 ;
14607     wxSize *arg3 = 0 ;
14608     wxDC *arg4 = (wxDC *) 0 ;
14609     wxPoint *arg5 = 0 ;
14610     int arg6 = (int) wxCOPY ;
14611     bool arg7 = (bool) false ;
14612     wxPoint const &arg8_defvalue = wxDefaultPosition ;
14613     wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
14614     bool result;
14615     wxPoint temp2 ;
14616     wxSize temp3 ;
14617     wxPoint temp5 ;
14618     wxPoint temp8 ;
14619     PyObject * obj0 = 0 ;
14620     PyObject * obj1 = 0 ;
14621     PyObject * obj2 = 0 ;
14622     PyObject * obj3 = 0 ;
14623     PyObject * obj4 = 0 ;
14624     PyObject * obj5 = 0 ;
14625     PyObject * obj6 = 0 ;
14626     PyObject * obj7 = 0 ;
14627     char *kwnames[] = {
14628         (char *) "self",(char *) "destPt",(char *) "sz",(char *) "source",(char *) "srcPt",(char *) "rop",(char *) "useMask",(char *) "srcPtMask", NULL
14629     };
14630
14631     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:DC_BlitPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
14632     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14633     if (SWIG_arg_fail(1)) SWIG_fail;
14634     {
14635         arg2 = &temp2;
14636         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14637     }
14638     {
14639         arg3 = &temp3;
14640         if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14641     }
14642     SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14643     if (SWIG_arg_fail(4)) SWIG_fail;
14644     {
14645         arg5 = &temp5;
14646         if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
14647     }
14648     if (obj5) {
14649         {
14650             arg6 = (int)(SWIG_As_int(obj5));
14651             if (SWIG_arg_fail(6)) SWIG_fail;
14652         }
14653     }
14654     if (obj6) {
14655         {
14656             arg7 = (bool)(SWIG_As_bool(obj6));
14657             if (SWIG_arg_fail(7)) SWIG_fail;
14658         }
14659     }
14660     if (obj7) {
14661         {
14662             arg8 = &temp8;
14663             if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
14664         }
14665     }
14666     {
14667         PyThreadState* __tstate = wxPyBeginAllowThreads();
14668         result = (bool)(arg1)->Blit((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,(wxPoint const &)*arg5,arg6,arg7,(wxPoint const &)*arg8);
14669
14670         wxPyEndAllowThreads(__tstate);
14671         if (PyErr_Occurred()) SWIG_fail;
14672     }
14673     {
14674         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14675     }
14676     return resultobj;
14677     fail:
14678     return NULL;
14679 }
14680
14681
14682 static PyObject *_wrap_DC_SetClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14683     PyObject *resultobj;
14684     wxDC *arg1 = (wxDC *) 0 ;
14685     int arg2 ;
14686     int arg3 ;
14687     int arg4 ;
14688     int arg5 ;
14689     PyObject * obj0 = 0 ;
14690     PyObject * obj1 = 0 ;
14691     PyObject * obj2 = 0 ;
14692     PyObject * obj3 = 0 ;
14693     PyObject * obj4 = 0 ;
14694     char *kwnames[] = {
14695         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
14696     };
14697
14698     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_SetClippingRegion",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14699     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14700     if (SWIG_arg_fail(1)) SWIG_fail;
14701     {
14702         arg2 = (int)(SWIG_As_int(obj1));
14703         if (SWIG_arg_fail(2)) SWIG_fail;
14704     }
14705     {
14706         arg3 = (int)(SWIG_As_int(obj2));
14707         if (SWIG_arg_fail(3)) SWIG_fail;
14708     }
14709     {
14710         arg4 = (int)(SWIG_As_int(obj3));
14711         if (SWIG_arg_fail(4)) SWIG_fail;
14712     }
14713     {
14714         arg5 = (int)(SWIG_As_int(obj4));
14715         if (SWIG_arg_fail(5)) SWIG_fail;
14716     }
14717     {
14718         PyThreadState* __tstate = wxPyBeginAllowThreads();
14719         (arg1)->SetClippingRegion(arg2,arg3,arg4,arg5);
14720
14721         wxPyEndAllowThreads(__tstate);
14722         if (PyErr_Occurred()) SWIG_fail;
14723     }
14724     Py_INCREF(Py_None); resultobj = Py_None;
14725     return resultobj;
14726     fail:
14727     return NULL;
14728 }
14729
14730
14731 static PyObject *_wrap_DC_SetClippingRegionPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14732     PyObject *resultobj;
14733     wxDC *arg1 = (wxDC *) 0 ;
14734     wxPoint *arg2 = 0 ;
14735     wxSize *arg3 = 0 ;
14736     wxPoint temp2 ;
14737     wxSize temp3 ;
14738     PyObject * obj0 = 0 ;
14739     PyObject * obj1 = 0 ;
14740     PyObject * obj2 = 0 ;
14741     char *kwnames[] = {
14742         (char *) "self",(char *) "pt",(char *) "sz", NULL
14743     };
14744
14745     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetClippingRegionPointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14746     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14747     if (SWIG_arg_fail(1)) SWIG_fail;
14748     {
14749         arg2 = &temp2;
14750         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14751     }
14752     {
14753         arg3 = &temp3;
14754         if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14755     }
14756     {
14757         PyThreadState* __tstate = wxPyBeginAllowThreads();
14758         (arg1)->SetClippingRegion((wxPoint const &)*arg2,(wxSize const &)*arg3);
14759
14760         wxPyEndAllowThreads(__tstate);
14761         if (PyErr_Occurred()) SWIG_fail;
14762     }
14763     Py_INCREF(Py_None); resultobj = Py_None;
14764     return resultobj;
14765     fail:
14766     return NULL;
14767 }
14768
14769
14770 static PyObject *_wrap_DC_SetClippingRegionAsRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14771     PyObject *resultobj;
14772     wxDC *arg1 = (wxDC *) 0 ;
14773     wxRegion *arg2 = 0 ;
14774     PyObject * obj0 = 0 ;
14775     PyObject * obj1 = 0 ;
14776     char *kwnames[] = {
14777         (char *) "self",(char *) "region", NULL
14778     };
14779
14780     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRegionAsRegion",kwnames,&obj0,&obj1)) goto fail;
14781     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14782     if (SWIG_arg_fail(1)) SWIG_fail;
14783     {
14784         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
14785         if (SWIG_arg_fail(2)) SWIG_fail;
14786         if (arg2 == NULL) {
14787             SWIG_null_ref("wxRegion");
14788         }
14789         if (SWIG_arg_fail(2)) SWIG_fail;
14790     }
14791     {
14792         PyThreadState* __tstate = wxPyBeginAllowThreads();
14793         (arg1)->SetClippingRegion((wxRegion const &)*arg2);
14794
14795         wxPyEndAllowThreads(__tstate);
14796         if (PyErr_Occurred()) SWIG_fail;
14797     }
14798     Py_INCREF(Py_None); resultobj = Py_None;
14799     return resultobj;
14800     fail:
14801     return NULL;
14802 }
14803
14804
14805 static PyObject *_wrap_DC_SetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
14806     PyObject *resultobj;
14807     wxDC *arg1 = (wxDC *) 0 ;
14808     wxRect *arg2 = 0 ;
14809     wxRect temp2 ;
14810     PyObject * obj0 = 0 ;
14811     PyObject * obj1 = 0 ;
14812     char *kwnames[] = {
14813         (char *) "self",(char *) "rect", NULL
14814     };
14815
14816     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRect",kwnames,&obj0,&obj1)) goto fail;
14817     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14818     if (SWIG_arg_fail(1)) SWIG_fail;
14819     {
14820         arg2 = &temp2;
14821         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14822     }
14823     {
14824         PyThreadState* __tstate = wxPyBeginAllowThreads();
14825         (arg1)->SetClippingRegion((wxRect const &)*arg2);
14826
14827         wxPyEndAllowThreads(__tstate);
14828         if (PyErr_Occurred()) SWIG_fail;
14829     }
14830     Py_INCREF(Py_None); resultobj = Py_None;
14831     return resultobj;
14832     fail:
14833     return NULL;
14834 }
14835
14836
14837 static PyObject *_wrap_DC_DrawLines(PyObject *, PyObject *args, PyObject *kwargs) {
14838     PyObject *resultobj;
14839     wxDC *arg1 = (wxDC *) 0 ;
14840     int arg2 ;
14841     wxPoint *arg3 = (wxPoint *) 0 ;
14842     int arg4 = (int) 0 ;
14843     int arg5 = (int) 0 ;
14844     PyObject * obj0 = 0 ;
14845     PyObject * obj1 = 0 ;
14846     PyObject * obj2 = 0 ;
14847     PyObject * obj3 = 0 ;
14848     char *kwnames[] = {
14849         (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset", NULL
14850     };
14851
14852     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DC_DrawLines",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14853     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14854     if (SWIG_arg_fail(1)) SWIG_fail;
14855     {
14856         arg3 = wxPoint_LIST_helper(obj1, &arg2);
14857         if (arg3 == NULL) SWIG_fail;
14858     }
14859     if (obj2) {
14860         {
14861             arg4 = (int)(SWIG_As_int(obj2));
14862             if (SWIG_arg_fail(4)) SWIG_fail;
14863         }
14864     }
14865     if (obj3) {
14866         {
14867             arg5 = (int)(SWIG_As_int(obj3));
14868             if (SWIG_arg_fail(5)) SWIG_fail;
14869         }
14870     }
14871     {
14872         PyThreadState* __tstate = wxPyBeginAllowThreads();
14873         (arg1)->DrawLines(arg2,arg3,arg4,arg5);
14874
14875         wxPyEndAllowThreads(__tstate);
14876         if (PyErr_Occurred()) SWIG_fail;
14877     }
14878     Py_INCREF(Py_None); resultobj = Py_None;
14879     {
14880         if (arg3) delete [] arg3;
14881     }
14882     return resultobj;
14883     fail:
14884     {
14885         if (arg3) delete [] arg3;
14886     }
14887     return NULL;
14888 }
14889
14890
14891 static PyObject *_wrap_DC_DrawPolygon(PyObject *, PyObject *args, PyObject *kwargs) {
14892     PyObject *resultobj;
14893     wxDC *arg1 = (wxDC *) 0 ;
14894     int arg2 ;
14895     wxPoint *arg3 = (wxPoint *) 0 ;
14896     int arg4 = (int) 0 ;
14897     int arg5 = (int) 0 ;
14898     int arg6 = (int) wxODDEVEN_RULE ;
14899     PyObject * obj0 = 0 ;
14900     PyObject * obj1 = 0 ;
14901     PyObject * obj2 = 0 ;
14902     PyObject * obj3 = 0 ;
14903     PyObject * obj4 = 0 ;
14904     char *kwnames[] = {
14905         (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset",(char *) "fillStyle", NULL
14906     };
14907
14908     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DC_DrawPolygon",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14909     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14910     if (SWIG_arg_fail(1)) SWIG_fail;
14911     {
14912         arg3 = wxPoint_LIST_helper(obj1, &arg2);
14913         if (arg3 == NULL) SWIG_fail;
14914     }
14915     if (obj2) {
14916         {
14917             arg4 = (int)(SWIG_As_int(obj2));
14918             if (SWIG_arg_fail(4)) SWIG_fail;
14919         }
14920     }
14921     if (obj3) {
14922         {
14923             arg5 = (int)(SWIG_As_int(obj3));
14924             if (SWIG_arg_fail(5)) SWIG_fail;
14925         }
14926     }
14927     if (obj4) {
14928         {
14929             arg6 = (int)(SWIG_As_int(obj4));
14930             if (SWIG_arg_fail(6)) SWIG_fail;
14931         }
14932     }
14933     {
14934         PyThreadState* __tstate = wxPyBeginAllowThreads();
14935         (arg1)->DrawPolygon(arg2,arg3,arg4,arg5,arg6);
14936
14937         wxPyEndAllowThreads(__tstate);
14938         if (PyErr_Occurred()) SWIG_fail;
14939     }
14940     Py_INCREF(Py_None); resultobj = Py_None;
14941     {
14942         if (arg3) delete [] arg3;
14943     }
14944     return resultobj;
14945     fail:
14946     {
14947         if (arg3) delete [] arg3;
14948     }
14949     return NULL;
14950 }
14951
14952
14953 static PyObject *_wrap_DC_DrawLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14954     PyObject *resultobj;
14955     wxDC *arg1 = (wxDC *) 0 ;
14956     wxString *arg2 = 0 ;
14957     wxRect *arg3 = 0 ;
14958     int arg4 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14959     int arg5 = (int) -1 ;
14960     bool temp2 = false ;
14961     wxRect temp3 ;
14962     PyObject * obj0 = 0 ;
14963     PyObject * obj1 = 0 ;
14964     PyObject * obj2 = 0 ;
14965     PyObject * obj3 = 0 ;
14966     PyObject * obj4 = 0 ;
14967     char *kwnames[] = {
14968         (char *) "self",(char *) "text",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
14969     };
14970
14971     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:DC_DrawLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14972     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14973     if (SWIG_arg_fail(1)) SWIG_fail;
14974     {
14975         arg2 = wxString_in_helper(obj1);
14976         if (arg2 == NULL) SWIG_fail;
14977         temp2 = true;
14978     }
14979     {
14980         arg3 = &temp3;
14981         if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
14982     }
14983     if (obj3) {
14984         {
14985             arg4 = (int)(SWIG_As_int(obj3));
14986             if (SWIG_arg_fail(4)) SWIG_fail;
14987         }
14988     }
14989     if (obj4) {
14990         {
14991             arg5 = (int)(SWIG_As_int(obj4));
14992             if (SWIG_arg_fail(5)) SWIG_fail;
14993         }
14994     }
14995     {
14996         PyThreadState* __tstate = wxPyBeginAllowThreads();
14997         (arg1)->DrawLabel((wxString const &)*arg2,(wxRect const &)*arg3,arg4,arg5);
14998
14999         wxPyEndAllowThreads(__tstate);
15000         if (PyErr_Occurred()) SWIG_fail;
15001     }
15002     Py_INCREF(Py_None); resultobj = Py_None;
15003     {
15004         if (temp2)
15005         delete arg2;
15006     }
15007     return resultobj;
15008     fail:
15009     {
15010         if (temp2)
15011         delete arg2;
15012     }
15013     return NULL;
15014 }
15015
15016
15017 static PyObject *_wrap_DC_DrawImageLabel(PyObject *, PyObject *args, PyObject *kwargs) {
15018     PyObject *resultobj;
15019     wxDC *arg1 = (wxDC *) 0 ;
15020     wxString *arg2 = 0 ;
15021     wxBitmap *arg3 = 0 ;
15022     wxRect *arg4 = 0 ;
15023     int arg5 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
15024     int arg6 = (int) -1 ;
15025     wxRect result;
15026     bool temp2 = false ;
15027     wxRect temp4 ;
15028     PyObject * obj0 = 0 ;
15029     PyObject * obj1 = 0 ;
15030     PyObject * obj2 = 0 ;
15031     PyObject * obj3 = 0 ;
15032     PyObject * obj4 = 0 ;
15033     PyObject * obj5 = 0 ;
15034     char *kwnames[] = {
15035         (char *) "self",(char *) "text",(char *) "image",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
15036     };
15037
15038     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:DC_DrawImageLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
15039     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15040     if (SWIG_arg_fail(1)) SWIG_fail;
15041     {
15042         arg2 = wxString_in_helper(obj1);
15043         if (arg2 == NULL) SWIG_fail;
15044         temp2 = true;
15045     }
15046     {
15047         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
15048         if (SWIG_arg_fail(3)) SWIG_fail;
15049         if (arg3 == NULL) {
15050             SWIG_null_ref("wxBitmap");
15051         }
15052         if (SWIG_arg_fail(3)) SWIG_fail;
15053     }
15054     {
15055         arg4 = &temp4;
15056         if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
15057     }
15058     if (obj4) {
15059         {
15060             arg5 = (int)(SWIG_As_int(obj4));
15061             if (SWIG_arg_fail(5)) SWIG_fail;
15062         }
15063     }
15064     if (obj5) {
15065         {
15066             arg6 = (int)(SWIG_As_int(obj5));
15067             if (SWIG_arg_fail(6)) SWIG_fail;
15068         }
15069     }
15070     {
15071         PyThreadState* __tstate = wxPyBeginAllowThreads();
15072         result = wxDC_DrawImageLabel(arg1,(wxString const &)*arg2,(wxBitmap const &)*arg3,(wxRect const &)*arg4,arg5,arg6);
15073
15074         wxPyEndAllowThreads(__tstate);
15075         if (PyErr_Occurred()) SWIG_fail;
15076     }
15077     {
15078         wxRect * resultptr;
15079         resultptr = new wxRect((wxRect &)(result));
15080         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
15081     }
15082     {
15083         if (temp2)
15084         delete arg2;
15085     }
15086     return resultobj;
15087     fail:
15088     {
15089         if (temp2)
15090         delete arg2;
15091     }
15092     return NULL;
15093 }
15094
15095
15096 static PyObject *_wrap_DC_DrawSpline(PyObject *, PyObject *args, PyObject *kwargs) {
15097     PyObject *resultobj;
15098     wxDC *arg1 = (wxDC *) 0 ;
15099     int arg2 ;
15100     wxPoint *arg3 = (wxPoint *) 0 ;
15101     PyObject * obj0 = 0 ;
15102     PyObject * obj1 = 0 ;
15103     char *kwnames[] = {
15104         (char *) "self",(char *) "points", NULL
15105     };
15106
15107     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawSpline",kwnames,&obj0,&obj1)) goto fail;
15108     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15109     if (SWIG_arg_fail(1)) SWIG_fail;
15110     {
15111         arg3 = wxPoint_LIST_helper(obj1, &arg2);
15112         if (arg3 == NULL) SWIG_fail;
15113     }
15114     {
15115         PyThreadState* __tstate = wxPyBeginAllowThreads();
15116         (arg1)->DrawSpline(arg2,arg3);
15117
15118         wxPyEndAllowThreads(__tstate);
15119         if (PyErr_Occurred()) SWIG_fail;
15120     }
15121     Py_INCREF(Py_None); resultobj = Py_None;
15122     {
15123         if (arg3) delete [] arg3;
15124     }
15125     return resultobj;
15126     fail:
15127     {
15128         if (arg3) delete [] arg3;
15129     }
15130     return NULL;
15131 }
15132
15133
15134 static PyObject *_wrap_DC_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
15135     PyObject *resultobj;
15136     wxDC *arg1 = (wxDC *) 0 ;
15137     PyObject * obj0 = 0 ;
15138     char *kwnames[] = {
15139         (char *) "self", NULL
15140     };
15141
15142     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Clear",kwnames,&obj0)) goto fail;
15143     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15144     if (SWIG_arg_fail(1)) SWIG_fail;
15145     {
15146         PyThreadState* __tstate = wxPyBeginAllowThreads();
15147         (arg1)->Clear();
15148
15149         wxPyEndAllowThreads(__tstate);
15150         if (PyErr_Occurred()) SWIG_fail;
15151     }
15152     Py_INCREF(Py_None); resultobj = Py_None;
15153     return resultobj;
15154     fail:
15155     return NULL;
15156 }
15157
15158
15159 static PyObject *_wrap_DC_StartDoc(PyObject *, PyObject *args, PyObject *kwargs) {
15160     PyObject *resultobj;
15161     wxDC *arg1 = (wxDC *) 0 ;
15162     wxString *arg2 = 0 ;
15163     bool result;
15164     bool temp2 = false ;
15165     PyObject * obj0 = 0 ;
15166     PyObject * obj1 = 0 ;
15167     char *kwnames[] = {
15168         (char *) "self",(char *) "message", NULL
15169     };
15170
15171     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_StartDoc",kwnames,&obj0,&obj1)) goto fail;
15172     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15173     if (SWIG_arg_fail(1)) SWIG_fail;
15174     {
15175         arg2 = wxString_in_helper(obj1);
15176         if (arg2 == NULL) SWIG_fail;
15177         temp2 = true;
15178     }
15179     {
15180         PyThreadState* __tstate = wxPyBeginAllowThreads();
15181         result = (bool)(arg1)->StartDoc((wxString const &)*arg2);
15182
15183         wxPyEndAllowThreads(__tstate);
15184         if (PyErr_Occurred()) SWIG_fail;
15185     }
15186     {
15187         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15188     }
15189     {
15190         if (temp2)
15191         delete arg2;
15192     }
15193     return resultobj;
15194     fail:
15195     {
15196         if (temp2)
15197         delete arg2;
15198     }
15199     return NULL;
15200 }
15201
15202
15203 static PyObject *_wrap_DC_EndDoc(PyObject *, PyObject *args, PyObject *kwargs) {
15204     PyObject *resultobj;
15205     wxDC *arg1 = (wxDC *) 0 ;
15206     PyObject * obj0 = 0 ;
15207     char *kwnames[] = {
15208         (char *) "self", NULL
15209     };
15210
15211     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDoc",kwnames,&obj0)) goto fail;
15212     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15213     if (SWIG_arg_fail(1)) SWIG_fail;
15214     {
15215         PyThreadState* __tstate = wxPyBeginAllowThreads();
15216         (arg1)->EndDoc();
15217
15218         wxPyEndAllowThreads(__tstate);
15219         if (PyErr_Occurred()) SWIG_fail;
15220     }
15221     Py_INCREF(Py_None); resultobj = Py_None;
15222     return resultobj;
15223     fail:
15224     return NULL;
15225 }
15226
15227
15228 static PyObject *_wrap_DC_StartPage(PyObject *, PyObject *args, PyObject *kwargs) {
15229     PyObject *resultobj;
15230     wxDC *arg1 = (wxDC *) 0 ;
15231     PyObject * obj0 = 0 ;
15232     char *kwnames[] = {
15233         (char *) "self", NULL
15234     };
15235
15236     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_StartPage",kwnames,&obj0)) goto fail;
15237     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15238     if (SWIG_arg_fail(1)) SWIG_fail;
15239     {
15240         PyThreadState* __tstate = wxPyBeginAllowThreads();
15241         (arg1)->StartPage();
15242
15243         wxPyEndAllowThreads(__tstate);
15244         if (PyErr_Occurred()) SWIG_fail;
15245     }
15246     Py_INCREF(Py_None); resultobj = Py_None;
15247     return resultobj;
15248     fail:
15249     return NULL;
15250 }
15251
15252
15253 static PyObject *_wrap_DC_EndPage(PyObject *, PyObject *args, PyObject *kwargs) {
15254     PyObject *resultobj;
15255     wxDC *arg1 = (wxDC *) 0 ;
15256     PyObject * obj0 = 0 ;
15257     char *kwnames[] = {
15258         (char *) "self", NULL
15259     };
15260
15261     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndPage",kwnames,&obj0)) goto fail;
15262     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15263     if (SWIG_arg_fail(1)) SWIG_fail;
15264     {
15265         PyThreadState* __tstate = wxPyBeginAllowThreads();
15266         (arg1)->EndPage();
15267
15268         wxPyEndAllowThreads(__tstate);
15269         if (PyErr_Occurred()) SWIG_fail;
15270     }
15271     Py_INCREF(Py_None); resultobj = Py_None;
15272     return resultobj;
15273     fail:
15274     return NULL;
15275 }
15276
15277
15278 static PyObject *_wrap_DC_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
15279     PyObject *resultobj;
15280     wxDC *arg1 = (wxDC *) 0 ;
15281     wxFont *arg2 = 0 ;
15282     PyObject * obj0 = 0 ;
15283     PyObject * obj1 = 0 ;
15284     char *kwnames[] = {
15285         (char *) "self",(char *) "font", NULL
15286     };
15287
15288     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetFont",kwnames,&obj0,&obj1)) goto fail;
15289     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15290     if (SWIG_arg_fail(1)) SWIG_fail;
15291     {
15292         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15293         if (SWIG_arg_fail(2)) SWIG_fail;
15294         if (arg2 == NULL) {
15295             SWIG_null_ref("wxFont");
15296         }
15297         if (SWIG_arg_fail(2)) SWIG_fail;
15298     }
15299     {
15300         PyThreadState* __tstate = wxPyBeginAllowThreads();
15301         (arg1)->SetFont((wxFont const &)*arg2);
15302
15303         wxPyEndAllowThreads(__tstate);
15304         if (PyErr_Occurred()) SWIG_fail;
15305     }
15306     Py_INCREF(Py_None); resultobj = Py_None;
15307     return resultobj;
15308     fail:
15309     return NULL;
15310 }
15311
15312
15313 static PyObject *_wrap_DC_SetPen(PyObject *, PyObject *args, PyObject *kwargs) {
15314     PyObject *resultobj;
15315     wxDC *arg1 = (wxDC *) 0 ;
15316     wxPen *arg2 = 0 ;
15317     PyObject * obj0 = 0 ;
15318     PyObject * obj1 = 0 ;
15319     char *kwnames[] = {
15320         (char *) "self",(char *) "pen", NULL
15321     };
15322
15323     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPen",kwnames,&obj0,&obj1)) goto fail;
15324     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15325     if (SWIG_arg_fail(1)) SWIG_fail;
15326     {
15327         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
15328         if (SWIG_arg_fail(2)) SWIG_fail;
15329         if (arg2 == NULL) {
15330             SWIG_null_ref("wxPen");
15331         }
15332         if (SWIG_arg_fail(2)) SWIG_fail;
15333     }
15334     {
15335         PyThreadState* __tstate = wxPyBeginAllowThreads();
15336         (arg1)->SetPen((wxPen const &)*arg2);
15337
15338         wxPyEndAllowThreads(__tstate);
15339         if (PyErr_Occurred()) SWIG_fail;
15340     }
15341     Py_INCREF(Py_None); resultobj = Py_None;
15342     return resultobj;
15343     fail:
15344     return NULL;
15345 }
15346
15347
15348 static PyObject *_wrap_DC_SetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
15349     PyObject *resultobj;
15350     wxDC *arg1 = (wxDC *) 0 ;
15351     wxBrush *arg2 = 0 ;
15352     PyObject * obj0 = 0 ;
15353     PyObject * obj1 = 0 ;
15354     char *kwnames[] = {
15355         (char *) "self",(char *) "brush", NULL
15356     };
15357
15358     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBrush",kwnames,&obj0,&obj1)) goto fail;
15359     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15360     if (SWIG_arg_fail(1)) SWIG_fail;
15361     {
15362         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
15363         if (SWIG_arg_fail(2)) SWIG_fail;
15364         if (arg2 == NULL) {
15365             SWIG_null_ref("wxBrush");
15366         }
15367         if (SWIG_arg_fail(2)) SWIG_fail;
15368     }
15369     {
15370         PyThreadState* __tstate = wxPyBeginAllowThreads();
15371         (arg1)->SetBrush((wxBrush const &)*arg2);
15372
15373         wxPyEndAllowThreads(__tstate);
15374         if (PyErr_Occurred()) SWIG_fail;
15375     }
15376     Py_INCREF(Py_None); resultobj = Py_None;
15377     return resultobj;
15378     fail:
15379     return NULL;
15380 }
15381
15382
15383 static PyObject *_wrap_DC_SetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15384     PyObject *resultobj;
15385     wxDC *arg1 = (wxDC *) 0 ;
15386     wxBrush *arg2 = 0 ;
15387     PyObject * obj0 = 0 ;
15388     PyObject * obj1 = 0 ;
15389     char *kwnames[] = {
15390         (char *) "self",(char *) "brush", NULL
15391     };
15392
15393     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackground",kwnames,&obj0,&obj1)) goto fail;
15394     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15395     if (SWIG_arg_fail(1)) SWIG_fail;
15396     {
15397         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
15398         if (SWIG_arg_fail(2)) SWIG_fail;
15399         if (arg2 == NULL) {
15400             SWIG_null_ref("wxBrush");
15401         }
15402         if (SWIG_arg_fail(2)) SWIG_fail;
15403     }
15404     {
15405         PyThreadState* __tstate = wxPyBeginAllowThreads();
15406         (arg1)->SetBackground((wxBrush const &)*arg2);
15407
15408         wxPyEndAllowThreads(__tstate);
15409         if (PyErr_Occurred()) SWIG_fail;
15410     }
15411     Py_INCREF(Py_None); resultobj = Py_None;
15412     return resultobj;
15413     fail:
15414     return NULL;
15415 }
15416
15417
15418 static PyObject *_wrap_DC_SetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
15419     PyObject *resultobj;
15420     wxDC *arg1 = (wxDC *) 0 ;
15421     int arg2 ;
15422     PyObject * obj0 = 0 ;
15423     PyObject * obj1 = 0 ;
15424     char *kwnames[] = {
15425         (char *) "self",(char *) "mode", NULL
15426     };
15427
15428     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackgroundMode",kwnames,&obj0,&obj1)) goto fail;
15429     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15430     if (SWIG_arg_fail(1)) SWIG_fail;
15431     {
15432         arg2 = (int)(SWIG_As_int(obj1));
15433         if (SWIG_arg_fail(2)) SWIG_fail;
15434     }
15435     {
15436         PyThreadState* __tstate = wxPyBeginAllowThreads();
15437         (arg1)->SetBackgroundMode(arg2);
15438
15439         wxPyEndAllowThreads(__tstate);
15440         if (PyErr_Occurred()) SWIG_fail;
15441     }
15442     Py_INCREF(Py_None); resultobj = Py_None;
15443     return resultobj;
15444     fail:
15445     return NULL;
15446 }
15447
15448
15449 static PyObject *_wrap_DC_SetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
15450     PyObject *resultobj;
15451     wxDC *arg1 = (wxDC *) 0 ;
15452     wxPalette *arg2 = 0 ;
15453     PyObject * obj0 = 0 ;
15454     PyObject * obj1 = 0 ;
15455     char *kwnames[] = {
15456         (char *) "self",(char *) "palette", NULL
15457     };
15458
15459     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPalette",kwnames,&obj0,&obj1)) goto fail;
15460     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15461     if (SWIG_arg_fail(1)) SWIG_fail;
15462     {
15463         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
15464         if (SWIG_arg_fail(2)) SWIG_fail;
15465         if (arg2 == NULL) {
15466             SWIG_null_ref("wxPalette");
15467         }
15468         if (SWIG_arg_fail(2)) SWIG_fail;
15469     }
15470     {
15471         PyThreadState* __tstate = wxPyBeginAllowThreads();
15472         (arg1)->SetPalette((wxPalette const &)*arg2);
15473
15474         wxPyEndAllowThreads(__tstate);
15475         if (PyErr_Occurred()) SWIG_fail;
15476     }
15477     Py_INCREF(Py_None); resultobj = Py_None;
15478     return resultobj;
15479     fail:
15480     return NULL;
15481 }
15482
15483
15484 static PyObject *_wrap_DC_DestroyClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
15485     PyObject *resultobj;
15486     wxDC *arg1 = (wxDC *) 0 ;
15487     PyObject * obj0 = 0 ;
15488     char *kwnames[] = {
15489         (char *) "self", NULL
15490     };
15491
15492     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_DestroyClippingRegion",kwnames,&obj0)) goto fail;
15493     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15494     if (SWIG_arg_fail(1)) SWIG_fail;
15495     {
15496         PyThreadState* __tstate = wxPyBeginAllowThreads();
15497         (arg1)->DestroyClippingRegion();
15498
15499         wxPyEndAllowThreads(__tstate);
15500         if (PyErr_Occurred()) SWIG_fail;
15501     }
15502     Py_INCREF(Py_None); resultobj = Py_None;
15503     return resultobj;
15504     fail:
15505     return NULL;
15506 }
15507
15508
15509 static PyObject *_wrap_DC_GetClippingBox(PyObject *, PyObject *args, PyObject *kwargs) {
15510     PyObject *resultobj;
15511     wxDC *arg1 = (wxDC *) 0 ;
15512     int *arg2 = (int *) 0 ;
15513     int *arg3 = (int *) 0 ;
15514     int *arg4 = (int *) 0 ;
15515     int *arg5 = (int *) 0 ;
15516     int temp2 ;
15517     int res2 = 0 ;
15518     int temp3 ;
15519     int res3 = 0 ;
15520     int temp4 ;
15521     int res4 = 0 ;
15522     int temp5 ;
15523     int res5 = 0 ;
15524     PyObject * obj0 = 0 ;
15525     char *kwnames[] = {
15526         (char *) "self", NULL
15527     };
15528
15529     arg2 = &temp2; res2 = SWIG_NEWOBJ;
15530     arg3 = &temp3; res3 = SWIG_NEWOBJ;
15531     arg4 = &temp4; res4 = SWIG_NEWOBJ;
15532     arg5 = &temp5; res5 = SWIG_NEWOBJ;
15533     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingBox",kwnames,&obj0)) goto fail;
15534     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15535     if (SWIG_arg_fail(1)) SWIG_fail;
15536     {
15537         PyThreadState* __tstate = wxPyBeginAllowThreads();
15538         ((wxDC const *)arg1)->GetClippingBox(arg2,arg3,arg4,arg5);
15539
15540         wxPyEndAllowThreads(__tstate);
15541         if (PyErr_Occurred()) SWIG_fail;
15542     }
15543     Py_INCREF(Py_None); resultobj = Py_None;
15544     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15545     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15546     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15547     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15548     resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15549     SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15550     resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15551     SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15552     return resultobj;
15553     fail:
15554     return NULL;
15555 }
15556
15557
15558 static PyObject *_wrap_DC_GetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
15559     PyObject *resultobj;
15560     wxDC *arg1 = (wxDC *) 0 ;
15561     wxRect result;
15562     PyObject * obj0 = 0 ;
15563     char *kwnames[] = {
15564         (char *) "self", NULL
15565     };
15566
15567     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingRect",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         result = wxDC_GetClippingRect(arg1);
15573
15574         wxPyEndAllowThreads(__tstate);
15575         if (PyErr_Occurred()) SWIG_fail;
15576     }
15577     {
15578         wxRect * resultptr;
15579         resultptr = new wxRect((wxRect &)(result));
15580         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
15581     }
15582     return resultobj;
15583     fail:
15584     return NULL;
15585 }
15586
15587
15588 static PyObject *_wrap_DC_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
15589     PyObject *resultobj;
15590     wxDC *arg1 = (wxDC *) 0 ;
15591     int result;
15592     PyObject * obj0 = 0 ;
15593     char *kwnames[] = {
15594         (char *) "self", NULL
15595     };
15596
15597     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharHeight",kwnames,&obj0)) goto fail;
15598     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15599     if (SWIG_arg_fail(1)) SWIG_fail;
15600     {
15601         PyThreadState* __tstate = wxPyBeginAllowThreads();
15602         result = (int)((wxDC const *)arg1)->GetCharHeight();
15603
15604         wxPyEndAllowThreads(__tstate);
15605         if (PyErr_Occurred()) SWIG_fail;
15606     }
15607     {
15608         resultobj = SWIG_From_int((int)(result));
15609     }
15610     return resultobj;
15611     fail:
15612     return NULL;
15613 }
15614
15615
15616 static PyObject *_wrap_DC_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
15617     PyObject *resultobj;
15618     wxDC *arg1 = (wxDC *) 0 ;
15619     int result;
15620     PyObject * obj0 = 0 ;
15621     char *kwnames[] = {
15622         (char *) "self", NULL
15623     };
15624
15625     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharWidth",kwnames,&obj0)) goto fail;
15626     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15627     if (SWIG_arg_fail(1)) SWIG_fail;
15628     {
15629         PyThreadState* __tstate = wxPyBeginAllowThreads();
15630         result = (int)((wxDC const *)arg1)->GetCharWidth();
15631
15632         wxPyEndAllowThreads(__tstate);
15633         if (PyErr_Occurred()) SWIG_fail;
15634     }
15635     {
15636         resultobj = SWIG_From_int((int)(result));
15637     }
15638     return resultobj;
15639     fail:
15640     return NULL;
15641 }
15642
15643
15644 static PyObject *_wrap_DC_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15645     PyObject *resultobj;
15646     wxDC *arg1 = (wxDC *) 0 ;
15647     wxString *arg2 = 0 ;
15648     int *arg3 = (int *) 0 ;
15649     int *arg4 = (int *) 0 ;
15650     bool temp2 = false ;
15651     int temp3 ;
15652     int res3 = 0 ;
15653     int temp4 ;
15654     int res4 = 0 ;
15655     PyObject * obj0 = 0 ;
15656     PyObject * obj1 = 0 ;
15657     char *kwnames[] = {
15658         (char *) "self",(char *) "string", NULL
15659     };
15660
15661     arg3 = &temp3; res3 = SWIG_NEWOBJ;
15662     arg4 = &temp4; res4 = SWIG_NEWOBJ;
15663     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
15664     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15665     if (SWIG_arg_fail(1)) SWIG_fail;
15666     {
15667         arg2 = wxString_in_helper(obj1);
15668         if (arg2 == NULL) SWIG_fail;
15669         temp2 = true;
15670     }
15671     {
15672         PyThreadState* __tstate = wxPyBeginAllowThreads();
15673         (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
15674
15675         wxPyEndAllowThreads(__tstate);
15676         if (PyErr_Occurred()) SWIG_fail;
15677     }
15678     Py_INCREF(Py_None); resultobj = Py_None;
15679     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15680     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15681     resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15682     SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15683     {
15684         if (temp2)
15685         delete arg2;
15686     }
15687     return resultobj;
15688     fail:
15689     {
15690         if (temp2)
15691         delete arg2;
15692     }
15693     return NULL;
15694 }
15695
15696
15697 static PyObject *_wrap_DC_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15698     PyObject *resultobj;
15699     wxDC *arg1 = (wxDC *) 0 ;
15700     wxString *arg2 = 0 ;
15701     int *arg3 = (int *) 0 ;
15702     int *arg4 = (int *) 0 ;
15703     int *arg5 = (int *) 0 ;
15704     int *arg6 = (int *) 0 ;
15705     wxFont *arg7 = (wxFont *) NULL ;
15706     bool temp2 = false ;
15707     int temp3 ;
15708     int res3 = 0 ;
15709     int temp4 ;
15710     int res4 = 0 ;
15711     int temp5 ;
15712     int res5 = 0 ;
15713     int temp6 ;
15714     int res6 = 0 ;
15715     PyObject * obj0 = 0 ;
15716     PyObject * obj1 = 0 ;
15717     PyObject * obj2 = 0 ;
15718     char *kwnames[] = {
15719         (char *) "self",(char *) "string",(char *) "font", NULL
15720     };
15721
15722     arg3 = &temp3; res3 = SWIG_NEWOBJ;
15723     arg4 = &temp4; res4 = SWIG_NEWOBJ;
15724     arg5 = &temp5; res5 = SWIG_NEWOBJ;
15725     arg6 = &temp6; res6 = SWIG_NEWOBJ;
15726     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15727     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15728     if (SWIG_arg_fail(1)) SWIG_fail;
15729     {
15730         arg2 = wxString_in_helper(obj1);
15731         if (arg2 == NULL) SWIG_fail;
15732         temp2 = true;
15733     }
15734     if (obj2) {
15735         SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15736         if (SWIG_arg_fail(7)) SWIG_fail;
15737     }
15738     {
15739         PyThreadState* __tstate = wxPyBeginAllowThreads();
15740         (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
15741
15742         wxPyEndAllowThreads(__tstate);
15743         if (PyErr_Occurred()) SWIG_fail;
15744     }
15745     Py_INCREF(Py_None); resultobj = Py_None;
15746     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15747     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15748     resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15749     SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15750     resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15751     SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15752     resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
15753     SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
15754     {
15755         if (temp2)
15756         delete arg2;
15757     }
15758     return resultobj;
15759     fail:
15760     {
15761         if (temp2)
15762         delete arg2;
15763     }
15764     return NULL;
15765 }
15766
15767
15768 static PyObject *_wrap_DC_GetMultiLineTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15769     PyObject *resultobj;
15770     wxDC *arg1 = (wxDC *) 0 ;
15771     wxString *arg2 = 0 ;
15772     int *arg3 = (int *) 0 ;
15773     int *arg4 = (int *) 0 ;
15774     int *arg5 = (int *) 0 ;
15775     wxFont *arg6 = (wxFont *) NULL ;
15776     bool temp2 = false ;
15777     int temp3 ;
15778     int res3 = 0 ;
15779     int temp4 ;
15780     int res4 = 0 ;
15781     int temp5 ;
15782     int res5 = 0 ;
15783     PyObject * obj0 = 0 ;
15784     PyObject * obj1 = 0 ;
15785     PyObject * obj2 = 0 ;
15786     char *kwnames[] = {
15787         (char *) "self",(char *) "text",(char *) "font", NULL
15788     };
15789
15790     arg3 = &temp3; res3 = SWIG_NEWOBJ;
15791     arg4 = &temp4; res4 = SWIG_NEWOBJ;
15792     arg5 = &temp5; res5 = SWIG_NEWOBJ;
15793     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetMultiLineTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15794     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15795     if (SWIG_arg_fail(1)) SWIG_fail;
15796     {
15797         arg2 = wxString_in_helper(obj1);
15798         if (arg2 == NULL) SWIG_fail;
15799         temp2 = true;
15800     }
15801     if (obj2) {
15802         SWIG_Python_ConvertPtr(obj2, (void **)&arg6, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15803         if (SWIG_arg_fail(6)) SWIG_fail;
15804     }
15805     {
15806         PyThreadState* __tstate = wxPyBeginAllowThreads();
15807         (arg1)->GetMultiLineTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6);
15808
15809         wxPyEndAllowThreads(__tstate);
15810         if (PyErr_Occurred()) SWIG_fail;
15811     }
15812     Py_INCREF(Py_None); resultobj = Py_None;
15813     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15814     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15815     resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15816     SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15817     resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15818     SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15819     {
15820         if (temp2)
15821         delete arg2;
15822     }
15823     return resultobj;
15824     fail:
15825     {
15826         if (temp2)
15827         delete arg2;
15828     }
15829     return NULL;
15830 }
15831
15832
15833 static PyObject *_wrap_DC_GetPartialTextExtents(PyObject *, PyObject *args, PyObject *kwargs) {
15834     PyObject *resultobj;
15835     wxDC *arg1 = (wxDC *) 0 ;
15836     wxString *arg2 = 0 ;
15837     wxArrayInt result;
15838     bool temp2 = false ;
15839     PyObject * obj0 = 0 ;
15840     PyObject * obj1 = 0 ;
15841     char *kwnames[] = {
15842         (char *) "self",(char *) "text", NULL
15843     };
15844
15845     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPartialTextExtents",kwnames,&obj0,&obj1)) goto fail;
15846     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15847     if (SWIG_arg_fail(1)) SWIG_fail;
15848     {
15849         arg2 = wxString_in_helper(obj1);
15850         if (arg2 == NULL) SWIG_fail;
15851         temp2 = true;
15852     }
15853     {
15854         PyThreadState* __tstate = wxPyBeginAllowThreads();
15855         result = wxDC_GetPartialTextExtents(arg1,(wxString const &)*arg2);
15856
15857         wxPyEndAllowThreads(__tstate);
15858         if (PyErr_Occurred()) SWIG_fail;
15859     }
15860     {
15861         resultobj = PyList_New(0);
15862         size_t idx;
15863         for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15864             PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15865             PyList_Append(resultobj, val);
15866             Py_DECREF(val);
15867         }
15868     }
15869     {
15870         if (temp2)
15871         delete arg2;
15872     }
15873     return resultobj;
15874     fail:
15875     {
15876         if (temp2)
15877         delete arg2;
15878     }
15879     return NULL;
15880 }
15881
15882
15883 static PyObject *_wrap_DC_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
15884     PyObject *resultobj;
15885     wxDC *arg1 = (wxDC *) 0 ;
15886     wxSize result;
15887     PyObject * obj0 = 0 ;
15888     char *kwnames[] = {
15889         (char *) "self", NULL
15890     };
15891
15892     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSize",kwnames,&obj0)) goto fail;
15893     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15894     if (SWIG_arg_fail(1)) SWIG_fail;
15895     {
15896         PyThreadState* __tstate = wxPyBeginAllowThreads();
15897         result = (arg1)->GetSize();
15898
15899         wxPyEndAllowThreads(__tstate);
15900         if (PyErr_Occurred()) SWIG_fail;
15901     }
15902     {
15903         wxSize * resultptr;
15904         resultptr = new wxSize((wxSize &)(result));
15905         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15906     }
15907     return resultobj;
15908     fail:
15909     return NULL;
15910 }
15911
15912
15913 static PyObject *_wrap_DC_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15914     PyObject *resultobj;
15915     wxDC *arg1 = (wxDC *) 0 ;
15916     int *arg2 = (int *) 0 ;
15917     int *arg3 = (int *) 0 ;
15918     int temp2 ;
15919     int res2 = 0 ;
15920     int temp3 ;
15921     int res3 = 0 ;
15922     PyObject * obj0 = 0 ;
15923     char *kwnames[] = {
15924         (char *) "self", NULL
15925     };
15926
15927     arg2 = &temp2; res2 = SWIG_NEWOBJ;
15928     arg3 = &temp3; res3 = SWIG_NEWOBJ;
15929     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeTuple",kwnames,&obj0)) goto fail;
15930     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15931     if (SWIG_arg_fail(1)) SWIG_fail;
15932     {
15933         PyThreadState* __tstate = wxPyBeginAllowThreads();
15934         (arg1)->GetSize(arg2,arg3);
15935
15936         wxPyEndAllowThreads(__tstate);
15937         if (PyErr_Occurred()) SWIG_fail;
15938     }
15939     Py_INCREF(Py_None); resultobj = Py_None;
15940     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15941     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15942     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15943     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15944     return resultobj;
15945     fail:
15946     return NULL;
15947 }
15948
15949
15950 static PyObject *_wrap_DC_GetSizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
15951     PyObject *resultobj;
15952     wxDC *arg1 = (wxDC *) 0 ;
15953     wxSize result;
15954     PyObject * obj0 = 0 ;
15955     char *kwnames[] = {
15956         (char *) "self", NULL
15957     };
15958
15959     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMM",kwnames,&obj0)) goto fail;
15960     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15961     if (SWIG_arg_fail(1)) SWIG_fail;
15962     {
15963         PyThreadState* __tstate = wxPyBeginAllowThreads();
15964         result = ((wxDC const *)arg1)->GetSizeMM();
15965
15966         wxPyEndAllowThreads(__tstate);
15967         if (PyErr_Occurred()) SWIG_fail;
15968     }
15969     {
15970         wxSize * resultptr;
15971         resultptr = new wxSize((wxSize &)(result));
15972         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15973     }
15974     return resultobj;
15975     fail:
15976     return NULL;
15977 }
15978
15979
15980 static PyObject *_wrap_DC_GetSizeMMTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15981     PyObject *resultobj;
15982     wxDC *arg1 = (wxDC *) 0 ;
15983     int *arg2 = (int *) 0 ;
15984     int *arg3 = (int *) 0 ;
15985     int temp2 ;
15986     int res2 = 0 ;
15987     int temp3 ;
15988     int res3 = 0 ;
15989     PyObject * obj0 = 0 ;
15990     char *kwnames[] = {
15991         (char *) "self", NULL
15992     };
15993
15994     arg2 = &temp2; res2 = SWIG_NEWOBJ;
15995     arg3 = &temp3; res3 = SWIG_NEWOBJ;
15996     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMMTuple",kwnames,&obj0)) goto fail;
15997     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15998     if (SWIG_arg_fail(1)) SWIG_fail;
15999     {
16000         PyThreadState* __tstate = wxPyBeginAllowThreads();
16001         ((wxDC const *)arg1)->GetSizeMM(arg2,arg3);
16002
16003         wxPyEndAllowThreads(__tstate);
16004         if (PyErr_Occurred()) SWIG_fail;
16005     }
16006     Py_INCREF(Py_None); resultobj = Py_None;
16007     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16008     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16009     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16010     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16011     return resultobj;
16012     fail:
16013     return NULL;
16014 }
16015
16016
16017 static PyObject *_wrap_DC_DeviceToLogicalX(PyObject *, PyObject *args, PyObject *kwargs) {
16018     PyObject *resultobj;
16019     wxDC *arg1 = (wxDC *) 0 ;
16020     int arg2 ;
16021     int result;
16022     PyObject * obj0 = 0 ;
16023     PyObject * obj1 = 0 ;
16024     char *kwnames[] = {
16025         (char *) "self",(char *) "x", NULL
16026     };
16027
16028     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalX",kwnames,&obj0,&obj1)) goto fail;
16029     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16030     if (SWIG_arg_fail(1)) SWIG_fail;
16031     {
16032         arg2 = (int)(SWIG_As_int(obj1));
16033         if (SWIG_arg_fail(2)) SWIG_fail;
16034     }
16035     {
16036         PyThreadState* __tstate = wxPyBeginAllowThreads();
16037         result = (int)((wxDC const *)arg1)->DeviceToLogicalX(arg2);
16038
16039         wxPyEndAllowThreads(__tstate);
16040         if (PyErr_Occurred()) SWIG_fail;
16041     }
16042     {
16043         resultobj = SWIG_From_int((int)(result));
16044     }
16045     return resultobj;
16046     fail:
16047     return NULL;
16048 }
16049
16050
16051 static PyObject *_wrap_DC_DeviceToLogicalY(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 *) "y", NULL
16060     };
16061
16062     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalY",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)->DeviceToLogicalY(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_DeviceToLogicalXRel(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 *) "x", NULL
16094     };
16095
16096     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalXRel",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)->DeviceToLogicalXRel(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_DeviceToLogicalYRel(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 *) "y", NULL
16128     };
16129
16130     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalYRel",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)->DeviceToLogicalYRel(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_LogicalToDeviceX(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 *) "x", NULL
16162     };
16163
16164     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceX",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)->LogicalToDeviceX(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_LogicalToDeviceY(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 *) "y", NULL
16196     };
16197
16198     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceY",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)->LogicalToDeviceY(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_LogicalToDeviceXRel(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 *) "x", NULL
16230     };
16231
16232     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceXRel",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)->LogicalToDeviceXRel(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_LogicalToDeviceYRel(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 *) "y", NULL
16264     };
16265
16266     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceYRel",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)->LogicalToDeviceYRel(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_CanDrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16290     PyObject *resultobj;
16291     wxDC *arg1 = (wxDC *) 0 ;
16292     bool result;
16293     PyObject * obj0 = 0 ;
16294     char *kwnames[] = {
16295         (char *) "self", NULL
16296     };
16297
16298     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanDrawBitmap",kwnames,&obj0)) goto fail;
16299     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16300     if (SWIG_arg_fail(1)) SWIG_fail;
16301     {
16302         PyThreadState* __tstate = wxPyBeginAllowThreads();
16303         result = (bool)((wxDC const *)arg1)->CanDrawBitmap();
16304
16305         wxPyEndAllowThreads(__tstate);
16306         if (PyErr_Occurred()) SWIG_fail;
16307     }
16308     {
16309         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16310     }
16311     return resultobj;
16312     fail:
16313     return NULL;
16314 }
16315
16316
16317 static PyObject *_wrap_DC_CanGetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
16318     PyObject *resultobj;
16319     wxDC *arg1 = (wxDC *) 0 ;
16320     bool result;
16321     PyObject * obj0 = 0 ;
16322     char *kwnames[] = {
16323         (char *) "self", NULL
16324     };
16325
16326     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanGetTextExtent",kwnames,&obj0)) goto fail;
16327     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16328     if (SWIG_arg_fail(1)) SWIG_fail;
16329     {
16330         PyThreadState* __tstate = wxPyBeginAllowThreads();
16331         result = (bool)((wxDC const *)arg1)->CanGetTextExtent();
16332
16333         wxPyEndAllowThreads(__tstate);
16334         if (PyErr_Occurred()) SWIG_fail;
16335     }
16336     {
16337         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16338     }
16339     return resultobj;
16340     fail:
16341     return NULL;
16342 }
16343
16344
16345 static PyObject *_wrap_DC_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
16346     PyObject *resultobj;
16347     wxDC *arg1 = (wxDC *) 0 ;
16348     int result;
16349     PyObject * obj0 = 0 ;
16350     char *kwnames[] = {
16351         (char *) "self", NULL
16352     };
16353
16354     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDepth",kwnames,&obj0)) goto fail;
16355     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16356     if (SWIG_arg_fail(1)) SWIG_fail;
16357     {
16358         PyThreadState* __tstate = wxPyBeginAllowThreads();
16359         result = (int)((wxDC const *)arg1)->GetDepth();
16360
16361         wxPyEndAllowThreads(__tstate);
16362         if (PyErr_Occurred()) SWIG_fail;
16363     }
16364     {
16365         resultobj = SWIG_From_int((int)(result));
16366     }
16367     return resultobj;
16368     fail:
16369     return NULL;
16370 }
16371
16372
16373 static PyObject *_wrap_DC_GetPPI(PyObject *, PyObject *args, PyObject *kwargs) {
16374     PyObject *resultobj;
16375     wxDC *arg1 = (wxDC *) 0 ;
16376     wxSize result;
16377     PyObject * obj0 = 0 ;
16378     char *kwnames[] = {
16379         (char *) "self", NULL
16380     };
16381
16382     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPPI",kwnames,&obj0)) goto fail;
16383     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16384     if (SWIG_arg_fail(1)) SWIG_fail;
16385     {
16386         PyThreadState* __tstate = wxPyBeginAllowThreads();
16387         result = ((wxDC const *)arg1)->GetPPI();
16388
16389         wxPyEndAllowThreads(__tstate);
16390         if (PyErr_Occurred()) SWIG_fail;
16391     }
16392     {
16393         wxSize * resultptr;
16394         resultptr = new wxSize((wxSize &)(result));
16395         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16396     }
16397     return resultobj;
16398     fail:
16399     return NULL;
16400 }
16401
16402
16403 static PyObject *_wrap_DC_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
16404     PyObject *resultobj;
16405     wxDC *arg1 = (wxDC *) 0 ;
16406     bool result;
16407     PyObject * obj0 = 0 ;
16408     char *kwnames[] = {
16409         (char *) "self", NULL
16410     };
16411
16412     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Ok",kwnames,&obj0)) goto fail;
16413     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16414     if (SWIG_arg_fail(1)) SWIG_fail;
16415     {
16416         PyThreadState* __tstate = wxPyBeginAllowThreads();
16417         result = (bool)((wxDC const *)arg1)->Ok();
16418
16419         wxPyEndAllowThreads(__tstate);
16420         if (PyErr_Occurred()) SWIG_fail;
16421     }
16422     {
16423         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16424     }
16425     return resultobj;
16426     fail:
16427     return NULL;
16428 }
16429
16430
16431 static PyObject *_wrap_DC_GetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
16432     PyObject *resultobj;
16433     wxDC *arg1 = (wxDC *) 0 ;
16434     int result;
16435     PyObject * obj0 = 0 ;
16436     char *kwnames[] = {
16437         (char *) "self", NULL
16438     };
16439
16440     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackgroundMode",kwnames,&obj0)) goto fail;
16441     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16442     if (SWIG_arg_fail(1)) SWIG_fail;
16443     {
16444         PyThreadState* __tstate = wxPyBeginAllowThreads();
16445         result = (int)((wxDC const *)arg1)->GetBackgroundMode();
16446
16447         wxPyEndAllowThreads(__tstate);
16448         if (PyErr_Occurred()) SWIG_fail;
16449     }
16450     {
16451         resultobj = SWIG_From_int((int)(result));
16452     }
16453     return resultobj;
16454     fail:
16455     return NULL;
16456 }
16457
16458
16459 static PyObject *_wrap_DC_GetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16460     PyObject *resultobj;
16461     wxDC *arg1 = (wxDC *) 0 ;
16462     wxBrush *result;
16463     PyObject * obj0 = 0 ;
16464     char *kwnames[] = {
16465         (char *) "self", NULL
16466     };
16467
16468     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackground",kwnames,&obj0)) goto fail;
16469     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16470     if (SWIG_arg_fail(1)) SWIG_fail;
16471     {
16472         PyThreadState* __tstate = wxPyBeginAllowThreads();
16473         {
16474             wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBackground();
16475             result = (wxBrush *) &_result_ref;
16476         }
16477
16478         wxPyEndAllowThreads(__tstate);
16479         if (PyErr_Occurred()) SWIG_fail;
16480     }
16481     {
16482         wxBrush* resultptr = new wxBrush(*result);
16483         resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
16484     }
16485     return resultobj;
16486     fail:
16487     return NULL;
16488 }
16489
16490
16491 static PyObject *_wrap_DC_GetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
16492     PyObject *resultobj;
16493     wxDC *arg1 = (wxDC *) 0 ;
16494     wxBrush *result;
16495     PyObject * obj0 = 0 ;
16496     char *kwnames[] = {
16497         (char *) "self", NULL
16498     };
16499
16500     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBrush",kwnames,&obj0)) goto fail;
16501     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16502     if (SWIG_arg_fail(1)) SWIG_fail;
16503     {
16504         PyThreadState* __tstate = wxPyBeginAllowThreads();
16505         {
16506             wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBrush();
16507             result = (wxBrush *) &_result_ref;
16508         }
16509
16510         wxPyEndAllowThreads(__tstate);
16511         if (PyErr_Occurred()) SWIG_fail;
16512     }
16513     {
16514         wxBrush* resultptr = new wxBrush(*result);
16515         resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
16516     }
16517     return resultobj;
16518     fail:
16519     return NULL;
16520 }
16521
16522
16523 static PyObject *_wrap_DC_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
16524     PyObject *resultobj;
16525     wxDC *arg1 = (wxDC *) 0 ;
16526     wxFont *result;
16527     PyObject * obj0 = 0 ;
16528     char *kwnames[] = {
16529         (char *) "self", NULL
16530     };
16531
16532     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetFont",kwnames,&obj0)) goto fail;
16533     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16534     if (SWIG_arg_fail(1)) SWIG_fail;
16535     {
16536         PyThreadState* __tstate = wxPyBeginAllowThreads();
16537         {
16538             wxFont const &_result_ref = ((wxDC const *)arg1)->GetFont();
16539             result = (wxFont *) &_result_ref;
16540         }
16541
16542         wxPyEndAllowThreads(__tstate);
16543         if (PyErr_Occurred()) SWIG_fail;
16544     }
16545     {
16546         wxFont* resultptr = new wxFont(*result);
16547         resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxFont, 1);
16548     }
16549     return resultobj;
16550     fail:
16551     return NULL;
16552 }
16553
16554
16555 static PyObject *_wrap_DC_GetPen(PyObject *, PyObject *args, PyObject *kwargs) {
16556     PyObject *resultobj;
16557     wxDC *arg1 = (wxDC *) 0 ;
16558     wxPen *result;
16559     PyObject * obj0 = 0 ;
16560     char *kwnames[] = {
16561         (char *) "self", NULL
16562     };
16563
16564     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPen",kwnames,&obj0)) goto fail;
16565     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16566     if (SWIG_arg_fail(1)) SWIG_fail;
16567     {
16568         PyThreadState* __tstate = wxPyBeginAllowThreads();
16569         {
16570             wxPen const &_result_ref = ((wxDC const *)arg1)->GetPen();
16571             result = (wxPen *) &_result_ref;
16572         }
16573
16574         wxPyEndAllowThreads(__tstate);
16575         if (PyErr_Occurred()) SWIG_fail;
16576     }
16577     {
16578         wxPen* resultptr = new wxPen(*result);
16579         resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxPen, 1);
16580     }
16581     return resultobj;
16582     fail:
16583     return NULL;
16584 }
16585
16586
16587 static PyObject *_wrap_DC_GetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16588     PyObject *resultobj;
16589     wxDC *arg1 = (wxDC *) 0 ;
16590     wxColour *result;
16591     PyObject * obj0 = 0 ;
16592     char *kwnames[] = {
16593         (char *) "self", NULL
16594     };
16595
16596     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextBackground",kwnames,&obj0)) goto fail;
16597     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16598     if (SWIG_arg_fail(1)) SWIG_fail;
16599     {
16600         PyThreadState* __tstate = wxPyBeginAllowThreads();
16601         {
16602             wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextBackground();
16603             result = (wxColour *) &_result_ref;
16604         }
16605
16606         wxPyEndAllowThreads(__tstate);
16607         if (PyErr_Occurred()) SWIG_fail;
16608     }
16609     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
16610     return resultobj;
16611     fail:
16612     return NULL;
16613 }
16614
16615
16616 static PyObject *_wrap_DC_GetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16617     PyObject *resultobj;
16618     wxDC *arg1 = (wxDC *) 0 ;
16619     wxColour *result;
16620     PyObject * obj0 = 0 ;
16621     char *kwnames[] = {
16622         (char *) "self", NULL
16623     };
16624
16625     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextForeground",kwnames,&obj0)) goto fail;
16626     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16627     if (SWIG_arg_fail(1)) SWIG_fail;
16628     {
16629         PyThreadState* __tstate = wxPyBeginAllowThreads();
16630         {
16631             wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextForeground();
16632             result = (wxColour *) &_result_ref;
16633         }
16634
16635         wxPyEndAllowThreads(__tstate);
16636         if (PyErr_Occurred()) SWIG_fail;
16637     }
16638     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
16639     return resultobj;
16640     fail:
16641     return NULL;
16642 }
16643
16644
16645 static PyObject *_wrap_DC_SetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16646     PyObject *resultobj;
16647     wxDC *arg1 = (wxDC *) 0 ;
16648     wxColour *arg2 = 0 ;
16649     wxColour temp2 ;
16650     PyObject * obj0 = 0 ;
16651     PyObject * obj1 = 0 ;
16652     char *kwnames[] = {
16653         (char *) "self",(char *) "colour", NULL
16654     };
16655
16656     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextForeground",kwnames,&obj0,&obj1)) goto fail;
16657     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16658     if (SWIG_arg_fail(1)) SWIG_fail;
16659     {
16660         arg2 = &temp2;
16661         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16662     }
16663     {
16664         PyThreadState* __tstate = wxPyBeginAllowThreads();
16665         (arg1)->SetTextForeground((wxColour const &)*arg2);
16666
16667         wxPyEndAllowThreads(__tstate);
16668         if (PyErr_Occurred()) SWIG_fail;
16669     }
16670     Py_INCREF(Py_None); resultobj = Py_None;
16671     return resultobj;
16672     fail:
16673     return NULL;
16674 }
16675
16676
16677 static PyObject *_wrap_DC_SetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16678     PyObject *resultobj;
16679     wxDC *arg1 = (wxDC *) 0 ;
16680     wxColour *arg2 = 0 ;
16681     wxColour temp2 ;
16682     PyObject * obj0 = 0 ;
16683     PyObject * obj1 = 0 ;
16684     char *kwnames[] = {
16685         (char *) "self",(char *) "colour", NULL
16686     };
16687
16688     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextBackground",kwnames,&obj0,&obj1)) goto fail;
16689     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16690     if (SWIG_arg_fail(1)) SWIG_fail;
16691     {
16692         arg2 = &temp2;
16693         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16694     }
16695     {
16696         PyThreadState* __tstate = wxPyBeginAllowThreads();
16697         (arg1)->SetTextBackground((wxColour const &)*arg2);
16698
16699         wxPyEndAllowThreads(__tstate);
16700         if (PyErr_Occurred()) SWIG_fail;
16701     }
16702     Py_INCREF(Py_None); resultobj = Py_None;
16703     return resultobj;
16704     fail:
16705     return NULL;
16706 }
16707
16708
16709 static PyObject *_wrap_DC_GetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16710     PyObject *resultobj;
16711     wxDC *arg1 = (wxDC *) 0 ;
16712     int result;
16713     PyObject * obj0 = 0 ;
16714     char *kwnames[] = {
16715         (char *) "self", NULL
16716     };
16717
16718     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetMapMode",kwnames,&obj0)) goto fail;
16719     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16720     if (SWIG_arg_fail(1)) SWIG_fail;
16721     {
16722         PyThreadState* __tstate = wxPyBeginAllowThreads();
16723         result = (int)((wxDC const *)arg1)->GetMapMode();
16724
16725         wxPyEndAllowThreads(__tstate);
16726         if (PyErr_Occurred()) SWIG_fail;
16727     }
16728     {
16729         resultobj = SWIG_From_int((int)(result));
16730     }
16731     return resultobj;
16732     fail:
16733     return NULL;
16734 }
16735
16736
16737 static PyObject *_wrap_DC_SetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16738     PyObject *resultobj;
16739     wxDC *arg1 = (wxDC *) 0 ;
16740     int arg2 ;
16741     PyObject * obj0 = 0 ;
16742     PyObject * obj1 = 0 ;
16743     char *kwnames[] = {
16744         (char *) "self",(char *) "mode", NULL
16745     };
16746
16747     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetMapMode",kwnames,&obj0,&obj1)) goto fail;
16748     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16749     if (SWIG_arg_fail(1)) SWIG_fail;
16750     {
16751         arg2 = (int)(SWIG_As_int(obj1));
16752         if (SWIG_arg_fail(2)) SWIG_fail;
16753     }
16754     {
16755         PyThreadState* __tstate = wxPyBeginAllowThreads();
16756         (arg1)->SetMapMode(arg2);
16757
16758         wxPyEndAllowThreads(__tstate);
16759         if (PyErr_Occurred()) SWIG_fail;
16760     }
16761     Py_INCREF(Py_None); resultobj = Py_None;
16762     return resultobj;
16763     fail:
16764     return NULL;
16765 }
16766
16767
16768 static PyObject *_wrap_DC_GetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16769     PyObject *resultobj;
16770     wxDC *arg1 = (wxDC *) 0 ;
16771     double *arg2 = (double *) 0 ;
16772     double *arg3 = (double *) 0 ;
16773     double temp2 ;
16774     int res2 = 0 ;
16775     double temp3 ;
16776     int res3 = 0 ;
16777     PyObject * obj0 = 0 ;
16778     char *kwnames[] = {
16779         (char *) "self", NULL
16780     };
16781
16782     arg2 = &temp2; res2 = SWIG_NEWOBJ;
16783     arg3 = &temp3; res3 = SWIG_NEWOBJ;
16784     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetUserScale",kwnames,&obj0)) goto fail;
16785     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16786     if (SWIG_arg_fail(1)) SWIG_fail;
16787     {
16788         PyThreadState* __tstate = wxPyBeginAllowThreads();
16789         ((wxDC const *)arg1)->GetUserScale(arg2,arg3);
16790
16791         wxPyEndAllowThreads(__tstate);
16792         if (PyErr_Occurred()) SWIG_fail;
16793     }
16794     Py_INCREF(Py_None); resultobj = Py_None;
16795     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16796     SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16797     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16798     SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16799     return resultobj;
16800     fail:
16801     return NULL;
16802 }
16803
16804
16805 static PyObject *_wrap_DC_SetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16806     PyObject *resultobj;
16807     wxDC *arg1 = (wxDC *) 0 ;
16808     double arg2 ;
16809     double arg3 ;
16810     PyObject * obj0 = 0 ;
16811     PyObject * obj1 = 0 ;
16812     PyObject * obj2 = 0 ;
16813     char *kwnames[] = {
16814         (char *) "self",(char *) "x",(char *) "y", NULL
16815     };
16816
16817     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetUserScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16818     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16819     if (SWIG_arg_fail(1)) SWIG_fail;
16820     {
16821         arg2 = (double)(SWIG_As_double(obj1));
16822         if (SWIG_arg_fail(2)) SWIG_fail;
16823     }
16824     {
16825         arg3 = (double)(SWIG_As_double(obj2));
16826         if (SWIG_arg_fail(3)) SWIG_fail;
16827     }
16828     {
16829         PyThreadState* __tstate = wxPyBeginAllowThreads();
16830         (arg1)->SetUserScale(arg2,arg3);
16831
16832         wxPyEndAllowThreads(__tstate);
16833         if (PyErr_Occurred()) SWIG_fail;
16834     }
16835     Py_INCREF(Py_None); resultobj = Py_None;
16836     return resultobj;
16837     fail:
16838     return NULL;
16839 }
16840
16841
16842 static PyObject *_wrap_DC_GetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16843     PyObject *resultobj;
16844     wxDC *arg1 = (wxDC *) 0 ;
16845     double *arg2 = (double *) 0 ;
16846     double *arg3 = (double *) 0 ;
16847     double temp2 ;
16848     int res2 = 0 ;
16849     double temp3 ;
16850     int res3 = 0 ;
16851     PyObject * obj0 = 0 ;
16852     char *kwnames[] = {
16853         (char *) "self", NULL
16854     };
16855
16856     arg2 = &temp2; res2 = SWIG_NEWOBJ;
16857     arg3 = &temp3; res3 = SWIG_NEWOBJ;
16858     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalScale",kwnames,&obj0)) goto fail;
16859     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16860     if (SWIG_arg_fail(1)) SWIG_fail;
16861     {
16862         PyThreadState* __tstate = wxPyBeginAllowThreads();
16863         (arg1)->GetLogicalScale(arg2,arg3);
16864
16865         wxPyEndAllowThreads(__tstate);
16866         if (PyErr_Occurred()) SWIG_fail;
16867     }
16868     Py_INCREF(Py_None); resultobj = Py_None;
16869     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16870     SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16871     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16872     SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16873     return resultobj;
16874     fail:
16875     return NULL;
16876 }
16877
16878
16879 static PyObject *_wrap_DC_SetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16880     PyObject *resultobj;
16881     wxDC *arg1 = (wxDC *) 0 ;
16882     double arg2 ;
16883     double arg3 ;
16884     PyObject * obj0 = 0 ;
16885     PyObject * obj1 = 0 ;
16886     PyObject * obj2 = 0 ;
16887     char *kwnames[] = {
16888         (char *) "self",(char *) "x",(char *) "y", NULL
16889     };
16890
16891     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16892     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16893     if (SWIG_arg_fail(1)) SWIG_fail;
16894     {
16895         arg2 = (double)(SWIG_As_double(obj1));
16896         if (SWIG_arg_fail(2)) SWIG_fail;
16897     }
16898     {
16899         arg3 = (double)(SWIG_As_double(obj2));
16900         if (SWIG_arg_fail(3)) SWIG_fail;
16901     }
16902     {
16903         PyThreadState* __tstate = wxPyBeginAllowThreads();
16904         (arg1)->SetLogicalScale(arg2,arg3);
16905
16906         wxPyEndAllowThreads(__tstate);
16907         if (PyErr_Occurred()) SWIG_fail;
16908     }
16909     Py_INCREF(Py_None); resultobj = Py_None;
16910     return resultobj;
16911     fail:
16912     return NULL;
16913 }
16914
16915
16916 static PyObject *_wrap_DC_GetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16917     PyObject *resultobj;
16918     wxDC *arg1 = (wxDC *) 0 ;
16919     wxPoint result;
16920     PyObject * obj0 = 0 ;
16921     char *kwnames[] = {
16922         (char *) "self", NULL
16923     };
16924
16925     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOrigin",kwnames,&obj0)) 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         PyThreadState* __tstate = wxPyBeginAllowThreads();
16930         result = ((wxDC const *)arg1)->GetLogicalOrigin();
16931
16932         wxPyEndAllowThreads(__tstate);
16933         if (PyErr_Occurred()) SWIG_fail;
16934     }
16935     {
16936         wxPoint * resultptr;
16937         resultptr = new wxPoint((wxPoint &)(result));
16938         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16939     }
16940     return resultobj;
16941     fail:
16942     return NULL;
16943 }
16944
16945
16946 static PyObject *_wrap_DC_GetLogicalOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16947     PyObject *resultobj;
16948     wxDC *arg1 = (wxDC *) 0 ;
16949     int *arg2 = (int *) 0 ;
16950     int *arg3 = (int *) 0 ;
16951     int temp2 ;
16952     int res2 = 0 ;
16953     int temp3 ;
16954     int res3 = 0 ;
16955     PyObject * obj0 = 0 ;
16956     char *kwnames[] = {
16957         (char *) "self", NULL
16958     };
16959
16960     arg2 = &temp2; res2 = SWIG_NEWOBJ;
16961     arg3 = &temp3; res3 = SWIG_NEWOBJ;
16962     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOriginTuple",kwnames,&obj0)) goto fail;
16963     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16964     if (SWIG_arg_fail(1)) SWIG_fail;
16965     {
16966         PyThreadState* __tstate = wxPyBeginAllowThreads();
16967         ((wxDC const *)arg1)->GetLogicalOrigin(arg2,arg3);
16968
16969         wxPyEndAllowThreads(__tstate);
16970         if (PyErr_Occurred()) SWIG_fail;
16971     }
16972     Py_INCREF(Py_None); resultobj = Py_None;
16973     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16974     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16975     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16976     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16977     return resultobj;
16978     fail:
16979     return NULL;
16980 }
16981
16982
16983 static PyObject *_wrap_DC_SetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16984     PyObject *resultobj;
16985     wxDC *arg1 = (wxDC *) 0 ;
16986     int arg2 ;
16987     int arg3 ;
16988     PyObject * obj0 = 0 ;
16989     PyObject * obj1 = 0 ;
16990     PyObject * obj2 = 0 ;
16991     char *kwnames[] = {
16992         (char *) "self",(char *) "x",(char *) "y", NULL
16993     };
16994
16995     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
16996     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16997     if (SWIG_arg_fail(1)) SWIG_fail;
16998     {
16999         arg2 = (int)(SWIG_As_int(obj1));
17000         if (SWIG_arg_fail(2)) SWIG_fail;
17001     }
17002     {
17003         arg3 = (int)(SWIG_As_int(obj2));
17004         if (SWIG_arg_fail(3)) SWIG_fail;
17005     }
17006     {
17007         PyThreadState* __tstate = wxPyBeginAllowThreads();
17008         (arg1)->SetLogicalOrigin(arg2,arg3);
17009
17010         wxPyEndAllowThreads(__tstate);
17011         if (PyErr_Occurred()) SWIG_fail;
17012     }
17013     Py_INCREF(Py_None); resultobj = Py_None;
17014     return resultobj;
17015     fail:
17016     return NULL;
17017 }
17018
17019
17020 static PyObject *_wrap_DC_SetLogicalOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
17021     PyObject *resultobj;
17022     wxDC *arg1 = (wxDC *) 0 ;
17023     wxPoint *arg2 = 0 ;
17024     wxPoint temp2 ;
17025     PyObject * obj0 = 0 ;
17026     PyObject * obj1 = 0 ;
17027     char *kwnames[] = {
17028         (char *) "self",(char *) "point", NULL
17029     };
17030
17031     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalOriginPoint",kwnames,&obj0,&obj1)) goto fail;
17032     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17033     if (SWIG_arg_fail(1)) SWIG_fail;
17034     {
17035         arg2 = &temp2;
17036         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17037     }
17038     {
17039         PyThreadState* __tstate = wxPyBeginAllowThreads();
17040         wxDC_SetLogicalOriginPoint(arg1,(wxPoint const &)*arg2);
17041
17042         wxPyEndAllowThreads(__tstate);
17043         if (PyErr_Occurred()) SWIG_fail;
17044     }
17045     Py_INCREF(Py_None); resultobj = Py_None;
17046     return resultobj;
17047     fail:
17048     return NULL;
17049 }
17050
17051
17052 static PyObject *_wrap_DC_GetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
17053     PyObject *resultobj;
17054     wxDC *arg1 = (wxDC *) 0 ;
17055     wxPoint result;
17056     PyObject * obj0 = 0 ;
17057     char *kwnames[] = {
17058         (char *) "self", NULL
17059     };
17060
17061     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOrigin",kwnames,&obj0)) goto fail;
17062     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17063     if (SWIG_arg_fail(1)) SWIG_fail;
17064     {
17065         PyThreadState* __tstate = wxPyBeginAllowThreads();
17066         result = ((wxDC const *)arg1)->GetDeviceOrigin();
17067
17068         wxPyEndAllowThreads(__tstate);
17069         if (PyErr_Occurred()) SWIG_fail;
17070     }
17071     {
17072         wxPoint * resultptr;
17073         resultptr = new wxPoint((wxPoint &)(result));
17074         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17075     }
17076     return resultobj;
17077     fail:
17078     return NULL;
17079 }
17080
17081
17082 static PyObject *_wrap_DC_GetDeviceOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17083     PyObject *resultobj;
17084     wxDC *arg1 = (wxDC *) 0 ;
17085     int *arg2 = (int *) 0 ;
17086     int *arg3 = (int *) 0 ;
17087     int temp2 ;
17088     int res2 = 0 ;
17089     int temp3 ;
17090     int res3 = 0 ;
17091     PyObject * obj0 = 0 ;
17092     char *kwnames[] = {
17093         (char *) "self", NULL
17094     };
17095
17096     arg2 = &temp2; res2 = SWIG_NEWOBJ;
17097     arg3 = &temp3; res3 = SWIG_NEWOBJ;
17098     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOriginTuple",kwnames,&obj0)) goto fail;
17099     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17100     if (SWIG_arg_fail(1)) SWIG_fail;
17101     {
17102         PyThreadState* __tstate = wxPyBeginAllowThreads();
17103         ((wxDC const *)arg1)->GetDeviceOrigin(arg2,arg3);
17104
17105         wxPyEndAllowThreads(__tstate);
17106         if (PyErr_Occurred()) SWIG_fail;
17107     }
17108     Py_INCREF(Py_None); resultobj = Py_None;
17109     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17110     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
17111     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17112     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
17113     return resultobj;
17114     fail:
17115     return NULL;
17116 }
17117
17118
17119 static PyObject *_wrap_DC_SetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
17120     PyObject *resultobj;
17121     wxDC *arg1 = (wxDC *) 0 ;
17122     int arg2 ;
17123     int arg3 ;
17124     PyObject * obj0 = 0 ;
17125     PyObject * obj1 = 0 ;
17126     PyObject * obj2 = 0 ;
17127     char *kwnames[] = {
17128         (char *) "self",(char *) "x",(char *) "y", NULL
17129     };
17130
17131     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetDeviceOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
17132     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17133     if (SWIG_arg_fail(1)) SWIG_fail;
17134     {
17135         arg2 = (int)(SWIG_As_int(obj1));
17136         if (SWIG_arg_fail(2)) SWIG_fail;
17137     }
17138     {
17139         arg3 = (int)(SWIG_As_int(obj2));
17140         if (SWIG_arg_fail(3)) SWIG_fail;
17141     }
17142     {
17143         PyThreadState* __tstate = wxPyBeginAllowThreads();
17144         (arg1)->SetDeviceOrigin(arg2,arg3);
17145
17146         wxPyEndAllowThreads(__tstate);
17147         if (PyErr_Occurred()) SWIG_fail;
17148     }
17149     Py_INCREF(Py_None); resultobj = Py_None;
17150     return resultobj;
17151     fail:
17152     return NULL;
17153 }
17154
17155
17156 static PyObject *_wrap_DC_SetDeviceOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
17157     PyObject *resultobj;
17158     wxDC *arg1 = (wxDC *) 0 ;
17159     wxPoint *arg2 = 0 ;
17160     wxPoint temp2 ;
17161     PyObject * obj0 = 0 ;
17162     PyObject * obj1 = 0 ;
17163     char *kwnames[] = {
17164         (char *) "self",(char *) "point", NULL
17165     };
17166
17167     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetDeviceOriginPoint",kwnames,&obj0,&obj1)) goto fail;
17168     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17169     if (SWIG_arg_fail(1)) SWIG_fail;
17170     {
17171         arg2 = &temp2;
17172         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17173     }
17174     {
17175         PyThreadState* __tstate = wxPyBeginAllowThreads();
17176         wxDC_SetDeviceOriginPoint(arg1,(wxPoint const &)*arg2);
17177
17178         wxPyEndAllowThreads(__tstate);
17179         if (PyErr_Occurred()) SWIG_fail;
17180     }
17181     Py_INCREF(Py_None); resultobj = Py_None;
17182     return resultobj;
17183     fail:
17184     return NULL;
17185 }
17186
17187
17188 static PyObject *_wrap_DC_SetAxisOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
17189     PyObject *resultobj;
17190     wxDC *arg1 = (wxDC *) 0 ;
17191     bool arg2 ;
17192     bool arg3 ;
17193     PyObject * obj0 = 0 ;
17194     PyObject * obj1 = 0 ;
17195     PyObject * obj2 = 0 ;
17196     char *kwnames[] = {
17197         (char *) "self",(char *) "xLeftRight",(char *) "yBottomUp", NULL
17198     };
17199
17200     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetAxisOrientation",kwnames,&obj0,&obj1,&obj2)) goto fail;
17201     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17202     if (SWIG_arg_fail(1)) SWIG_fail;
17203     {
17204         arg2 = (bool)(SWIG_As_bool(obj1));
17205         if (SWIG_arg_fail(2)) SWIG_fail;
17206     }
17207     {
17208         arg3 = (bool)(SWIG_As_bool(obj2));
17209         if (SWIG_arg_fail(3)) SWIG_fail;
17210     }
17211     {
17212         PyThreadState* __tstate = wxPyBeginAllowThreads();
17213         (arg1)->SetAxisOrientation(arg2,arg3);
17214
17215         wxPyEndAllowThreads(__tstate);
17216         if (PyErr_Occurred()) SWIG_fail;
17217     }
17218     Py_INCREF(Py_None); resultobj = Py_None;
17219     return resultobj;
17220     fail:
17221     return NULL;
17222 }
17223
17224
17225 static PyObject *_wrap_DC_GetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
17226     PyObject *resultobj;
17227     wxDC *arg1 = (wxDC *) 0 ;
17228     int result;
17229     PyObject * obj0 = 0 ;
17230     char *kwnames[] = {
17231         (char *) "self", NULL
17232     };
17233
17234     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalFunction",kwnames,&obj0)) 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         PyThreadState* __tstate = wxPyBeginAllowThreads();
17239         result = (int)((wxDC const *)arg1)->GetLogicalFunction();
17240
17241         wxPyEndAllowThreads(__tstate);
17242         if (PyErr_Occurred()) SWIG_fail;
17243     }
17244     {
17245         resultobj = SWIG_From_int((int)(result));
17246     }
17247     return resultobj;
17248     fail:
17249     return NULL;
17250 }
17251
17252
17253 static PyObject *_wrap_DC_SetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
17254     PyObject *resultobj;
17255     wxDC *arg1 = (wxDC *) 0 ;
17256     int arg2 ;
17257     PyObject * obj0 = 0 ;
17258     PyObject * obj1 = 0 ;
17259     char *kwnames[] = {
17260         (char *) "self",(char *) "function", NULL
17261     };
17262
17263     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalFunction",kwnames,&obj0,&obj1)) goto fail;
17264     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17265     if (SWIG_arg_fail(1)) SWIG_fail;
17266     {
17267         arg2 = (int)(SWIG_As_int(obj1));
17268         if (SWIG_arg_fail(2)) SWIG_fail;
17269     }
17270     {
17271         PyThreadState* __tstate = wxPyBeginAllowThreads();
17272         (arg1)->SetLogicalFunction(arg2);
17273
17274         wxPyEndAllowThreads(__tstate);
17275         if (PyErr_Occurred()) SWIG_fail;
17276     }
17277     Py_INCREF(Py_None); resultobj = Py_None;
17278     return resultobj;
17279     fail:
17280     return NULL;
17281 }
17282
17283
17284 static PyObject *_wrap_DC_ComputeScaleAndOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
17285     PyObject *resultobj;
17286     wxDC *arg1 = (wxDC *) 0 ;
17287     PyObject * obj0 = 0 ;
17288     char *kwnames[] = {
17289         (char *) "self", NULL
17290     };
17291
17292     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ComputeScaleAndOrigin",kwnames,&obj0)) goto fail;
17293     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17294     if (SWIG_arg_fail(1)) SWIG_fail;
17295     {
17296         PyThreadState* __tstate = wxPyBeginAllowThreads();
17297         (arg1)->ComputeScaleAndOrigin();
17298
17299         wxPyEndAllowThreads(__tstate);
17300         if (PyErr_Occurred()) SWIG_fail;
17301     }
17302     Py_INCREF(Py_None); resultobj = Py_None;
17303     return resultobj;
17304     fail:
17305     return NULL;
17306 }
17307
17308
17309 static PyObject *_wrap_DC_CalcBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
17310     PyObject *resultobj;
17311     wxDC *arg1 = (wxDC *) 0 ;
17312     int arg2 ;
17313     int arg3 ;
17314     PyObject * obj0 = 0 ;
17315     PyObject * obj1 = 0 ;
17316     PyObject * obj2 = 0 ;
17317     char *kwnames[] = {
17318         (char *) "self",(char *) "x",(char *) "y", NULL
17319     };
17320
17321     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CalcBoundingBox",kwnames,&obj0,&obj1,&obj2)) goto fail;
17322     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17323     if (SWIG_arg_fail(1)) SWIG_fail;
17324     {
17325         arg2 = (int)(SWIG_As_int(obj1));
17326         if (SWIG_arg_fail(2)) SWIG_fail;
17327     }
17328     {
17329         arg3 = (int)(SWIG_As_int(obj2));
17330         if (SWIG_arg_fail(3)) SWIG_fail;
17331     }
17332     {
17333         PyThreadState* __tstate = wxPyBeginAllowThreads();
17334         (arg1)->CalcBoundingBox(arg2,arg3);
17335
17336         wxPyEndAllowThreads(__tstate);
17337         if (PyErr_Occurred()) SWIG_fail;
17338     }
17339     Py_INCREF(Py_None); resultobj = Py_None;
17340     return resultobj;
17341     fail:
17342     return NULL;
17343 }
17344
17345
17346 static PyObject *_wrap_DC_CalcBoundingBoxPoint(PyObject *, PyObject *args, PyObject *kwargs) {
17347     PyObject *resultobj;
17348     wxDC *arg1 = (wxDC *) 0 ;
17349     wxPoint *arg2 = 0 ;
17350     wxPoint temp2 ;
17351     PyObject * obj0 = 0 ;
17352     PyObject * obj1 = 0 ;
17353     char *kwnames[] = {
17354         (char *) "self",(char *) "point", NULL
17355     };
17356
17357     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CalcBoundingBoxPoint",kwnames,&obj0,&obj1)) goto fail;
17358     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17359     if (SWIG_arg_fail(1)) SWIG_fail;
17360     {
17361         arg2 = &temp2;
17362         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17363     }
17364     {
17365         PyThreadState* __tstate = wxPyBeginAllowThreads();
17366         wxDC_CalcBoundingBoxPoint(arg1,(wxPoint const &)*arg2);
17367
17368         wxPyEndAllowThreads(__tstate);
17369         if (PyErr_Occurred()) SWIG_fail;
17370     }
17371     Py_INCREF(Py_None); resultobj = Py_None;
17372     return resultobj;
17373     fail:
17374     return NULL;
17375 }
17376
17377
17378 static PyObject *_wrap_DC_ResetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
17379     PyObject *resultobj;
17380     wxDC *arg1 = (wxDC *) 0 ;
17381     PyObject * obj0 = 0 ;
17382     char *kwnames[] = {
17383         (char *) "self", NULL
17384     };
17385
17386     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ResetBoundingBox",kwnames,&obj0)) goto fail;
17387     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17388     if (SWIG_arg_fail(1)) SWIG_fail;
17389     {
17390         PyThreadState* __tstate = wxPyBeginAllowThreads();
17391         (arg1)->ResetBoundingBox();
17392
17393         wxPyEndAllowThreads(__tstate);
17394         if (PyErr_Occurred()) SWIG_fail;
17395     }
17396     Py_INCREF(Py_None); resultobj = Py_None;
17397     return resultobj;
17398     fail:
17399     return NULL;
17400 }
17401
17402
17403 static PyObject *_wrap_DC_MinX(PyObject *, PyObject *args, PyObject *kwargs) {
17404     PyObject *resultobj;
17405     wxDC *arg1 = (wxDC *) 0 ;
17406     int result;
17407     PyObject * obj0 = 0 ;
17408     char *kwnames[] = {
17409         (char *) "self", NULL
17410     };
17411
17412     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinX",kwnames,&obj0)) goto fail;
17413     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17414     if (SWIG_arg_fail(1)) SWIG_fail;
17415     {
17416         PyThreadState* __tstate = wxPyBeginAllowThreads();
17417         result = (int)((wxDC const *)arg1)->MinX();
17418
17419         wxPyEndAllowThreads(__tstate);
17420         if (PyErr_Occurred()) SWIG_fail;
17421     }
17422     {
17423         resultobj = SWIG_From_int((int)(result));
17424     }
17425     return resultobj;
17426     fail:
17427     return NULL;
17428 }
17429
17430
17431 static PyObject *_wrap_DC_MaxX(PyObject *, PyObject *args, PyObject *kwargs) {
17432     PyObject *resultobj;
17433     wxDC *arg1 = (wxDC *) 0 ;
17434     int result;
17435     PyObject * obj0 = 0 ;
17436     char *kwnames[] = {
17437         (char *) "self", NULL
17438     };
17439
17440     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxX",kwnames,&obj0)) goto fail;
17441     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17442     if (SWIG_arg_fail(1)) SWIG_fail;
17443     {
17444         PyThreadState* __tstate = wxPyBeginAllowThreads();
17445         result = (int)((wxDC const *)arg1)->MaxX();
17446
17447         wxPyEndAllowThreads(__tstate);
17448         if (PyErr_Occurred()) SWIG_fail;
17449     }
17450     {
17451         resultobj = SWIG_From_int((int)(result));
17452     }
17453     return resultobj;
17454     fail:
17455     return NULL;
17456 }
17457
17458
17459 static PyObject *_wrap_DC_MinY(PyObject *, PyObject *args, PyObject *kwargs) {
17460     PyObject *resultobj;
17461     wxDC *arg1 = (wxDC *) 0 ;
17462     int result;
17463     PyObject * obj0 = 0 ;
17464     char *kwnames[] = {
17465         (char *) "self", NULL
17466     };
17467
17468     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinY",kwnames,&obj0)) goto fail;
17469     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17470     if (SWIG_arg_fail(1)) SWIG_fail;
17471     {
17472         PyThreadState* __tstate = wxPyBeginAllowThreads();
17473         result = (int)((wxDC const *)arg1)->MinY();
17474
17475         wxPyEndAllowThreads(__tstate);
17476         if (PyErr_Occurred()) SWIG_fail;
17477     }
17478     {
17479         resultobj = SWIG_From_int((int)(result));
17480     }
17481     return resultobj;
17482     fail:
17483     return NULL;
17484 }
17485
17486
17487 static PyObject *_wrap_DC_MaxY(PyObject *, PyObject *args, PyObject *kwargs) {
17488     PyObject *resultobj;
17489     wxDC *arg1 = (wxDC *) 0 ;
17490     int result;
17491     PyObject * obj0 = 0 ;
17492     char *kwnames[] = {
17493         (char *) "self", NULL
17494     };
17495
17496     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxY",kwnames,&obj0)) goto fail;
17497     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17498     if (SWIG_arg_fail(1)) SWIG_fail;
17499     {
17500         PyThreadState* __tstate = wxPyBeginAllowThreads();
17501         result = (int)((wxDC const *)arg1)->MaxY();
17502
17503         wxPyEndAllowThreads(__tstate);
17504         if (PyErr_Occurred()) SWIG_fail;
17505     }
17506     {
17507         resultobj = SWIG_From_int((int)(result));
17508     }
17509     return resultobj;
17510     fail:
17511     return NULL;
17512 }
17513
17514
17515 static PyObject *_wrap_DC_GetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
17516     PyObject *resultobj;
17517     wxDC *arg1 = (wxDC *) 0 ;
17518     int *arg2 = (int *) 0 ;
17519     int *arg3 = (int *) 0 ;
17520     int *arg4 = (int *) 0 ;
17521     int *arg5 = (int *) 0 ;
17522     int temp2 ;
17523     int res2 = 0 ;
17524     int temp3 ;
17525     int res3 = 0 ;
17526     int temp4 ;
17527     int res4 = 0 ;
17528     int temp5 ;
17529     int res5 = 0 ;
17530     PyObject * obj0 = 0 ;
17531     char *kwnames[] = {
17532         (char *) "self", NULL
17533     };
17534
17535     arg2 = &temp2; res2 = SWIG_NEWOBJ;
17536     arg3 = &temp3; res3 = SWIG_NEWOBJ;
17537     arg4 = &temp4; res4 = SWIG_NEWOBJ;
17538     arg5 = &temp5; res5 = SWIG_NEWOBJ;
17539     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBoundingBox",kwnames,&obj0)) goto fail;
17540     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17541     if (SWIG_arg_fail(1)) SWIG_fail;
17542     {
17543         PyThreadState* __tstate = wxPyBeginAllowThreads();
17544         wxDC_GetBoundingBox(arg1,arg2,arg3,arg4,arg5);
17545
17546         wxPyEndAllowThreads(__tstate);
17547         if (PyErr_Occurred()) SWIG_fail;
17548     }
17549     Py_INCREF(Py_None); resultobj = Py_None;
17550     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17551     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
17552     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17553     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
17554     resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
17555     SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
17556     resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
17557     SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
17558     return resultobj;
17559     fail:
17560     return NULL;
17561 }
17562
17563
17564 static PyObject *_wrap_DC_GetHDC(PyObject *, PyObject *args, PyObject *kwargs) {
17565     PyObject *resultobj;
17566     wxDC *arg1 = (wxDC *) 0 ;
17567     long result;
17568     PyObject * obj0 = 0 ;
17569     char *kwnames[] = {
17570         (char *) "self", NULL
17571     };
17572
17573     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetHDC",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         result = (long)(arg1)->GetHDC();
17579
17580         wxPyEndAllowThreads(__tstate);
17581         if (PyErr_Occurred()) SWIG_fail;
17582     }
17583     {
17584         resultobj = SWIG_From_long((long)(result));
17585     }
17586     return resultobj;
17587     fail:
17588     return NULL;
17589 }
17590
17591
17592 static PyObject *_wrap_DC__DrawPointList(PyObject *, PyObject *args, PyObject *kwargs) {
17593     PyObject *resultobj;
17594     wxDC *arg1 = (wxDC *) 0 ;
17595     PyObject *arg2 = (PyObject *) 0 ;
17596     PyObject *arg3 = (PyObject *) 0 ;
17597     PyObject *arg4 = (PyObject *) 0 ;
17598     PyObject *result;
17599     PyObject * obj0 = 0 ;
17600     PyObject * obj1 = 0 ;
17601     PyObject * obj2 = 0 ;
17602     PyObject * obj3 = 0 ;
17603     char *kwnames[] = {
17604         (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17605     };
17606
17607     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPointList",kwnames,&obj0,&obj1,&obj2,&obj3)) 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     arg2 = obj1;
17611     arg3 = obj2;
17612     arg4 = obj3;
17613     {
17614         PyThreadState* __tstate = wxPyBeginAllowThreads();
17615         result = (PyObject *)wxDC__DrawPointList(arg1,arg2,arg3,arg4);
17616
17617         wxPyEndAllowThreads(__tstate);
17618         if (PyErr_Occurred()) SWIG_fail;
17619     }
17620     resultobj = result;
17621     return resultobj;
17622     fail:
17623     return NULL;
17624 }
17625
17626
17627 static PyObject *_wrap_DC__DrawLineList(PyObject *, PyObject *args, PyObject *kwargs) {
17628     PyObject *resultobj;
17629     wxDC *arg1 = (wxDC *) 0 ;
17630     PyObject *arg2 = (PyObject *) 0 ;
17631     PyObject *arg3 = (PyObject *) 0 ;
17632     PyObject *arg4 = (PyObject *) 0 ;
17633     PyObject *result;
17634     PyObject * obj0 = 0 ;
17635     PyObject * obj1 = 0 ;
17636     PyObject * obj2 = 0 ;
17637     PyObject * obj3 = 0 ;
17638     char *kwnames[] = {
17639         (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17640     };
17641
17642     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawLineList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17643     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17644     if (SWIG_arg_fail(1)) SWIG_fail;
17645     arg2 = obj1;
17646     arg3 = obj2;
17647     arg4 = obj3;
17648     {
17649         PyThreadState* __tstate = wxPyBeginAllowThreads();
17650         result = (PyObject *)wxDC__DrawLineList(arg1,arg2,arg3,arg4);
17651
17652         wxPyEndAllowThreads(__tstate);
17653         if (PyErr_Occurred()) SWIG_fail;
17654     }
17655     resultobj = result;
17656     return resultobj;
17657     fail:
17658     return NULL;
17659 }
17660
17661
17662 static PyObject *_wrap_DC__DrawRectangleList(PyObject *, PyObject *args, PyObject *kwargs) {
17663     PyObject *resultobj;
17664     wxDC *arg1 = (wxDC *) 0 ;
17665     PyObject *arg2 = (PyObject *) 0 ;
17666     PyObject *arg3 = (PyObject *) 0 ;
17667     PyObject *arg4 = (PyObject *) 0 ;
17668     PyObject *result;
17669     PyObject * obj0 = 0 ;
17670     PyObject * obj1 = 0 ;
17671     PyObject * obj2 = 0 ;
17672     PyObject * obj3 = 0 ;
17673     char *kwnames[] = {
17674         (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17675     };
17676
17677     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawRectangleList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17678     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17679     if (SWIG_arg_fail(1)) SWIG_fail;
17680     arg2 = obj1;
17681     arg3 = obj2;
17682     arg4 = obj3;
17683     {
17684         PyThreadState* __tstate = wxPyBeginAllowThreads();
17685         result = (PyObject *)wxDC__DrawRectangleList(arg1,arg2,arg3,arg4);
17686
17687         wxPyEndAllowThreads(__tstate);
17688         if (PyErr_Occurred()) SWIG_fail;
17689     }
17690     resultobj = result;
17691     return resultobj;
17692     fail:
17693     return NULL;
17694 }
17695
17696
17697 static PyObject *_wrap_DC__DrawEllipseList(PyObject *, PyObject *args, PyObject *kwargs) {
17698     PyObject *resultobj;
17699     wxDC *arg1 = (wxDC *) 0 ;
17700     PyObject *arg2 = (PyObject *) 0 ;
17701     PyObject *arg3 = (PyObject *) 0 ;
17702     PyObject *arg4 = (PyObject *) 0 ;
17703     PyObject *result;
17704     PyObject * obj0 = 0 ;
17705     PyObject * obj1 = 0 ;
17706     PyObject * obj2 = 0 ;
17707     PyObject * obj3 = 0 ;
17708     char *kwnames[] = {
17709         (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17710     };
17711
17712     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawEllipseList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17713     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17714     if (SWIG_arg_fail(1)) SWIG_fail;
17715     arg2 = obj1;
17716     arg3 = obj2;
17717     arg4 = obj3;
17718     {
17719         PyThreadState* __tstate = wxPyBeginAllowThreads();
17720         result = (PyObject *)wxDC__DrawEllipseList(arg1,arg2,arg3,arg4);
17721
17722         wxPyEndAllowThreads(__tstate);
17723         if (PyErr_Occurred()) SWIG_fail;
17724     }
17725     resultobj = result;
17726     return resultobj;
17727     fail:
17728     return NULL;
17729 }
17730
17731
17732 static PyObject *_wrap_DC__DrawPolygonList(PyObject *, PyObject *args, PyObject *kwargs) {
17733     PyObject *resultobj;
17734     wxDC *arg1 = (wxDC *) 0 ;
17735     PyObject *arg2 = (PyObject *) 0 ;
17736     PyObject *arg3 = (PyObject *) 0 ;
17737     PyObject *arg4 = (PyObject *) 0 ;
17738     PyObject *result;
17739     PyObject * obj0 = 0 ;
17740     PyObject * obj1 = 0 ;
17741     PyObject * obj2 = 0 ;
17742     PyObject * obj3 = 0 ;
17743     char *kwnames[] = {
17744         (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17745     };
17746
17747     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPolygonList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17748     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17749     if (SWIG_arg_fail(1)) SWIG_fail;
17750     arg2 = obj1;
17751     arg3 = obj2;
17752     arg4 = obj3;
17753     {
17754         PyThreadState* __tstate = wxPyBeginAllowThreads();
17755         result = (PyObject *)wxDC__DrawPolygonList(arg1,arg2,arg3,arg4);
17756
17757         wxPyEndAllowThreads(__tstate);
17758         if (PyErr_Occurred()) SWIG_fail;
17759     }
17760     resultobj = result;
17761     return resultobj;
17762     fail:
17763     return NULL;
17764 }
17765
17766
17767 static PyObject *_wrap_DC__DrawTextList(PyObject *, PyObject *args, PyObject *kwargs) {
17768     PyObject *resultobj;
17769     wxDC *arg1 = (wxDC *) 0 ;
17770     PyObject *arg2 = (PyObject *) 0 ;
17771     PyObject *arg3 = (PyObject *) 0 ;
17772     PyObject *arg4 = (PyObject *) 0 ;
17773     PyObject *arg5 = (PyObject *) 0 ;
17774     PyObject *result;
17775     PyObject * obj0 = 0 ;
17776     PyObject * obj1 = 0 ;
17777     PyObject * obj2 = 0 ;
17778     PyObject * obj3 = 0 ;
17779     PyObject * obj4 = 0 ;
17780     char *kwnames[] = {
17781         (char *) "self",(char *) "textList",(char *) "pyPoints",(char *) "foregroundList",(char *) "backgroundList", NULL
17782     };
17783
17784     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC__DrawTextList",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
17785     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17786     if (SWIG_arg_fail(1)) SWIG_fail;
17787     arg2 = obj1;
17788     arg3 = obj2;
17789     arg4 = obj3;
17790     arg5 = obj4;
17791     {
17792         PyThreadState* __tstate = wxPyBeginAllowThreads();
17793         result = (PyObject *)wxDC__DrawTextList(arg1,arg2,arg3,arg4,arg5);
17794
17795         wxPyEndAllowThreads(__tstate);
17796         if (PyErr_Occurred()) SWIG_fail;
17797     }
17798     resultobj = result;
17799     return resultobj;
17800     fail:
17801     return NULL;
17802 }
17803
17804
17805 static PyObject * DC_swigregister(PyObject *, PyObject *args) {
17806     PyObject *obj;
17807     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17808     SWIG_TypeClientData(SWIGTYPE_p_wxDC, obj);
17809     Py_INCREF(obj);
17810     return Py_BuildValue((char *)"");
17811 }
17812 static PyObject *_wrap_new_MemoryDC(PyObject *, PyObject *args, PyObject *kwargs) {
17813     PyObject *resultobj;
17814     wxMemoryDC *result;
17815     char *kwnames[] = {
17816         NULL
17817     };
17818
17819     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryDC",kwnames)) goto fail;
17820     {
17821         if (!wxPyCheckForApp()) SWIG_fail;
17822         PyThreadState* __tstate = wxPyBeginAllowThreads();
17823         result = (wxMemoryDC *)new wxMemoryDC();
17824
17825         wxPyEndAllowThreads(__tstate);
17826         if (PyErr_Occurred()) SWIG_fail;
17827     }
17828     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17829     return resultobj;
17830     fail:
17831     return NULL;
17832 }
17833
17834
17835 static PyObject *_wrap_new_MemoryDCFromDC(PyObject *, PyObject *args, PyObject *kwargs) {
17836     PyObject *resultobj;
17837     wxDC *arg1 = (wxDC *) 0 ;
17838     wxMemoryDC *result;
17839     PyObject * obj0 = 0 ;
17840     char *kwnames[] = {
17841         (char *) "oldDC", NULL
17842     };
17843
17844     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_MemoryDCFromDC",kwnames,&obj0)) goto fail;
17845     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17846     if (SWIG_arg_fail(1)) SWIG_fail;
17847     {
17848         if (!wxPyCheckForApp()) SWIG_fail;
17849         PyThreadState* __tstate = wxPyBeginAllowThreads();
17850         result = (wxMemoryDC *)new wxMemoryDC(arg1);
17851
17852         wxPyEndAllowThreads(__tstate);
17853         if (PyErr_Occurred()) SWIG_fail;
17854     }
17855     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17856     return resultobj;
17857     fail:
17858     return NULL;
17859 }
17860
17861
17862 static PyObject *_wrap_MemoryDC_SelectObject(PyObject *, PyObject *args, PyObject *kwargs) {
17863     PyObject *resultobj;
17864     wxMemoryDC *arg1 = (wxMemoryDC *) 0 ;
17865     wxBitmap *arg2 = 0 ;
17866     PyObject * obj0 = 0 ;
17867     PyObject * obj1 = 0 ;
17868     char *kwnames[] = {
17869         (char *) "self",(char *) "bitmap", NULL
17870     };
17871
17872     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryDC_SelectObject",kwnames,&obj0,&obj1)) goto fail;
17873     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_EXCEPTION | 0);
17874     if (SWIG_arg_fail(1)) SWIG_fail;
17875     {
17876         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17877         if (SWIG_arg_fail(2)) SWIG_fail;
17878         if (arg2 == NULL) {
17879             SWIG_null_ref("wxBitmap");
17880         }
17881         if (SWIG_arg_fail(2)) SWIG_fail;
17882     }
17883     {
17884         PyThreadState* __tstate = wxPyBeginAllowThreads();
17885         (arg1)->SelectObject((wxBitmap const &)*arg2);
17886
17887         wxPyEndAllowThreads(__tstate);
17888         if (PyErr_Occurred()) SWIG_fail;
17889     }
17890     Py_INCREF(Py_None); resultobj = Py_None;
17891     return resultobj;
17892     fail:
17893     return NULL;
17894 }
17895
17896
17897 static PyObject * MemoryDC_swigregister(PyObject *, PyObject *args) {
17898     PyObject *obj;
17899     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17900     SWIG_TypeClientData(SWIGTYPE_p_wxMemoryDC, obj);
17901     Py_INCREF(obj);
17902     return Py_BuildValue((char *)"");
17903 }
17904 static PyObject *_wrap_new_BufferedDC__SWIG_0(PyObject *, PyObject *args) {
17905     PyObject *resultobj;
17906     wxDC *arg1 = (wxDC *) 0 ;
17907     wxBitmap const &arg2_defvalue = wxNullBitmap ;
17908     wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
17909     int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17910     wxBufferedDC *result;
17911     PyObject * obj0 = 0 ;
17912     PyObject * obj1 = 0 ;
17913     PyObject * obj2 = 0 ;
17914
17915     if(!PyArg_ParseTuple(args,(char *)"O|OO:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
17916     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17917     if (SWIG_arg_fail(1)) SWIG_fail;
17918     if (obj1) {
17919         {
17920             SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17921             if (SWIG_arg_fail(2)) SWIG_fail;
17922             if (arg2 == NULL) {
17923                 SWIG_null_ref("wxBitmap");
17924             }
17925             if (SWIG_arg_fail(2)) SWIG_fail;
17926         }
17927     }
17928     if (obj2) {
17929         {
17930             arg3 = (int)(SWIG_As_int(obj2));
17931             if (SWIG_arg_fail(3)) SWIG_fail;
17932         }
17933     }
17934     {
17935         if (!wxPyCheckForApp()) SWIG_fail;
17936         PyThreadState* __tstate = wxPyBeginAllowThreads();
17937         result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxBitmap const &)*arg2,arg3);
17938
17939         wxPyEndAllowThreads(__tstate);
17940         if (PyErr_Occurred()) SWIG_fail;
17941     }
17942     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17943     return resultobj;
17944     fail:
17945     return NULL;
17946 }
17947
17948
17949 static PyObject *_wrap_new_BufferedDC__SWIG_1(PyObject *, PyObject *args) {
17950     PyObject *resultobj;
17951     wxDC *arg1 = (wxDC *) 0 ;
17952     wxSize *arg2 = 0 ;
17953     int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17954     wxBufferedDC *result;
17955     wxSize temp2 ;
17956     PyObject * obj0 = 0 ;
17957     PyObject * obj1 = 0 ;
17958     PyObject * obj2 = 0 ;
17959
17960     if(!PyArg_ParseTuple(args,(char *)"OO|O:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
17961     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17962     if (SWIG_arg_fail(1)) SWIG_fail;
17963     {
17964         arg2 = &temp2;
17965         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17966     }
17967     if (obj2) {
17968         {
17969             arg3 = (int)(SWIG_As_int(obj2));
17970             if (SWIG_arg_fail(3)) SWIG_fail;
17971         }
17972     }
17973     {
17974         if (!wxPyCheckForApp()) SWIG_fail;
17975         PyThreadState* __tstate = wxPyBeginAllowThreads();
17976         result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxSize const &)*arg2,arg3);
17977
17978         wxPyEndAllowThreads(__tstate);
17979         if (PyErr_Occurred()) SWIG_fail;
17980     }
17981     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17982     return resultobj;
17983     fail:
17984     return NULL;
17985 }
17986
17987
17988 static PyObject *_wrap_new_BufferedDC(PyObject *self, PyObject *args) {
17989     int argc;
17990     PyObject *argv[4];
17991     int ii;
17992
17993     argc = PyObject_Length(args);
17994     for (ii = 0; (ii < argc) && (ii < 3); ii++) {
17995         argv[ii] = PyTuple_GetItem(args,ii);
17996     }
17997     if ((argc >= 1) && (argc <= 3)) {
17998         int _v;
17999         {
18000             void *ptr;
18001             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
18002                 _v = 0;
18003                 PyErr_Clear();
18004             } else {
18005                 _v = 1;
18006             }
18007         }
18008         if (_v) {
18009             if (argc <= 1) {
18010                 return _wrap_new_BufferedDC__SWIG_0(self,args);
18011             }
18012             {
18013                 void *ptr = 0;
18014                 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxBitmap, 0) == -1) {
18015                     _v = 0;
18016                     PyErr_Clear();
18017                 } else {
18018                     _v = (ptr != 0);
18019                 }
18020             }
18021             if (_v) {
18022                 if (argc <= 2) {
18023                     return _wrap_new_BufferedDC__SWIG_0(self,args);
18024                 }
18025                 _v = SWIG_Check_int(argv[2]);
18026                 if (_v) {
18027                     return _wrap_new_BufferedDC__SWIG_0(self,args);
18028                 }
18029             }
18030         }
18031     }
18032     if ((argc >= 2) && (argc <= 3)) {
18033         int _v;
18034         {
18035             void *ptr;
18036             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
18037                 _v = 0;
18038                 PyErr_Clear();
18039             } else {
18040                 _v = 1;
18041             }
18042         }
18043         if (_v) {
18044             {
18045                 _v = wxPySimple_typecheck(argv[1], wxT("wxSize"), 2);
18046             }
18047             if (_v) {
18048                 if (argc <= 2) {
18049                     return _wrap_new_BufferedDC__SWIG_1(self,args);
18050                 }
18051                 _v = SWIG_Check_int(argv[2]);
18052                 if (_v) {
18053                     return _wrap_new_BufferedDC__SWIG_1(self,args);
18054                 }
18055             }
18056         }
18057     }
18058
18059     PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_BufferedDC'");
18060     return NULL;
18061 }
18062
18063
18064 static PyObject *_wrap_delete_BufferedDC(PyObject *, PyObject *args, PyObject *kwargs) {
18065     PyObject *resultobj;
18066     wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
18067     PyObject * obj0 = 0 ;
18068     char *kwnames[] = {
18069         (char *) "self", NULL
18070     };
18071
18072     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BufferedDC",kwnames,&obj0)) goto fail;
18073     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
18074     if (SWIG_arg_fail(1)) SWIG_fail;
18075     {
18076         PyThreadState* __tstate = wxPyBeginAllowThreads();
18077         delete arg1;
18078
18079         wxPyEndAllowThreads(__tstate);
18080         if (PyErr_Occurred()) SWIG_fail;
18081     }
18082     Py_INCREF(Py_None); resultobj = Py_None;
18083     return resultobj;
18084     fail:
18085     return NULL;
18086 }
18087
18088
18089 static PyObject *_wrap_BufferedDC_UnMask(PyObject *, PyObject *args, PyObject *kwargs) {
18090     PyObject *resultobj;
18091     wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
18092     PyObject * obj0 = 0 ;
18093     char *kwnames[] = {
18094         (char *) "self", NULL
18095     };
18096
18097     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BufferedDC_UnMask",kwnames,&obj0)) goto fail;
18098     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
18099     if (SWIG_arg_fail(1)) SWIG_fail;
18100     {
18101         PyThreadState* __tstate = wxPyBeginAllowThreads();
18102         (arg1)->UnMask();
18103
18104         wxPyEndAllowThreads(__tstate);
18105         if (PyErr_Occurred()) SWIG_fail;
18106     }
18107     Py_INCREF(Py_None); resultobj = Py_None;
18108     return resultobj;
18109     fail:
18110     return NULL;
18111 }
18112
18113
18114 static PyObject * BufferedDC_swigregister(PyObject *, PyObject *args) {
18115     PyObject *obj;
18116     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18117     SWIG_TypeClientData(SWIGTYPE_p_wxBufferedDC, obj);
18118     Py_INCREF(obj);
18119     return Py_BuildValue((char *)"");
18120 }
18121 static PyObject *_wrap_new_BufferedPaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
18122     PyObject *resultobj;
18123     wxWindow *arg1 = (wxWindow *) 0 ;
18124     wxBitmap const &arg2_defvalue = wxNullBitmap ;
18125     wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
18126     int arg3 = (int) wxBUFFER_CLIENT_AREA ;
18127     wxBufferedPaintDC *result;
18128     PyObject * obj0 = 0 ;
18129     PyObject * obj1 = 0 ;
18130     PyObject * obj2 = 0 ;
18131     char *kwnames[] = {
18132         (char *) "window",(char *) "buffer",(char *) "style", NULL
18133     };
18134
18135     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_BufferedPaintDC",kwnames,&obj0,&obj1,&obj2)) goto fail;
18136     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18137     if (SWIG_arg_fail(1)) SWIG_fail;
18138     if (obj1) {
18139         {
18140             SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18141             if (SWIG_arg_fail(2)) SWIG_fail;
18142             if (arg2 == NULL) {
18143                 SWIG_null_ref("wxBitmap");
18144             }
18145             if (SWIG_arg_fail(2)) SWIG_fail;
18146         }
18147     }
18148     if (obj2) {
18149         {
18150             arg3 = (int)(SWIG_As_int(obj2));
18151             if (SWIG_arg_fail(3)) SWIG_fail;
18152         }
18153     }
18154     {
18155         if (!wxPyCheckForApp()) SWIG_fail;
18156         PyThreadState* __tstate = wxPyBeginAllowThreads();
18157         result = (wxBufferedPaintDC *)new wxBufferedPaintDC(arg1,(wxBitmap const &)*arg2,arg3);
18158
18159         wxPyEndAllowThreads(__tstate);
18160         if (PyErr_Occurred()) SWIG_fail;
18161     }
18162     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedPaintDC, 1);
18163     return resultobj;
18164     fail:
18165     return NULL;
18166 }
18167
18168
18169 static PyObject * BufferedPaintDC_swigregister(PyObject *, PyObject *args) {
18170     PyObject *obj;
18171     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18172     SWIG_TypeClientData(SWIGTYPE_p_wxBufferedPaintDC, obj);
18173     Py_INCREF(obj);
18174     return Py_BuildValue((char *)"");
18175 }
18176 static PyObject *_wrap_new_ScreenDC(PyObject *, PyObject *args, PyObject *kwargs) {
18177     PyObject *resultobj;
18178     wxScreenDC *result;
18179     char *kwnames[] = {
18180         NULL
18181     };
18182
18183     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ScreenDC",kwnames)) goto fail;
18184     {
18185         if (!wxPyCheckForApp()) SWIG_fail;
18186         PyThreadState* __tstate = wxPyBeginAllowThreads();
18187         result = (wxScreenDC *)new wxScreenDC();
18188
18189         wxPyEndAllowThreads(__tstate);
18190         if (PyErr_Occurred()) SWIG_fail;
18191     }
18192     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScreenDC, 1);
18193     return resultobj;
18194     fail:
18195     return NULL;
18196 }
18197
18198
18199 static PyObject *_wrap_ScreenDC_StartDrawingOnTopWin(PyObject *, PyObject *args, PyObject *kwargs) {
18200     PyObject *resultobj;
18201     wxScreenDC *arg1 = (wxScreenDC *) 0 ;
18202     wxWindow *arg2 = (wxWindow *) 0 ;
18203     bool result;
18204     PyObject * obj0 = 0 ;
18205     PyObject * obj1 = 0 ;
18206     char *kwnames[] = {
18207         (char *) "self",(char *) "window", NULL
18208     };
18209
18210     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScreenDC_StartDrawingOnTopWin",kwnames,&obj0,&obj1)) goto fail;
18211     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
18212     if (SWIG_arg_fail(1)) SWIG_fail;
18213     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18214     if (SWIG_arg_fail(2)) SWIG_fail;
18215     {
18216         PyThreadState* __tstate = wxPyBeginAllowThreads();
18217         result = (bool)(arg1)->StartDrawingOnTop(arg2);
18218
18219         wxPyEndAllowThreads(__tstate);
18220         if (PyErr_Occurred()) SWIG_fail;
18221     }
18222     {
18223         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18224     }
18225     return resultobj;
18226     fail:
18227     return NULL;
18228 }
18229
18230
18231 static PyObject *_wrap_ScreenDC_StartDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
18232     PyObject *resultobj;
18233     wxScreenDC *arg1 = (wxScreenDC *) 0 ;
18234     wxRect *arg2 = (wxRect *) NULL ;
18235     bool result;
18236     PyObject * obj0 = 0 ;
18237     PyObject * obj1 = 0 ;
18238     char *kwnames[] = {
18239         (char *) "self",(char *) "rect", NULL
18240     };
18241
18242     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ScreenDC_StartDrawingOnTop",kwnames,&obj0,&obj1)) goto fail;
18243     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
18244     if (SWIG_arg_fail(1)) SWIG_fail;
18245     if (obj1) {
18246         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
18247         if (SWIG_arg_fail(2)) SWIG_fail;
18248     }
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_EndDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
18266     PyObject *resultobj;
18267     wxScreenDC *arg1 = (wxScreenDC *) 0 ;
18268     bool result;
18269     PyObject * obj0 = 0 ;
18270     char *kwnames[] = {
18271         (char *) "self", NULL
18272     };
18273
18274     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScreenDC_EndDrawingOnTop",kwnames,&obj0)) goto fail;
18275     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
18276     if (SWIG_arg_fail(1)) SWIG_fail;
18277     {
18278         PyThreadState* __tstate = wxPyBeginAllowThreads();
18279         result = (bool)(arg1)->EndDrawingOnTop();
18280
18281         wxPyEndAllowThreads(__tstate);
18282         if (PyErr_Occurred()) SWIG_fail;
18283     }
18284     {
18285         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18286     }
18287     return resultobj;
18288     fail:
18289     return NULL;
18290 }
18291
18292
18293 static PyObject * ScreenDC_swigregister(PyObject *, PyObject *args) {
18294     PyObject *obj;
18295     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18296     SWIG_TypeClientData(SWIGTYPE_p_wxScreenDC, obj);
18297     Py_INCREF(obj);
18298     return Py_BuildValue((char *)"");
18299 }
18300 static PyObject *_wrap_new_ClientDC(PyObject *, PyObject *args, PyObject *kwargs) {
18301     PyObject *resultobj;
18302     wxWindow *arg1 = (wxWindow *) 0 ;
18303     wxClientDC *result;
18304     PyObject * obj0 = 0 ;
18305     char *kwnames[] = {
18306         (char *) "win", NULL
18307     };
18308
18309     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ClientDC",kwnames,&obj0)) goto fail;
18310     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18311     if (SWIG_arg_fail(1)) SWIG_fail;
18312     {
18313         if (!wxPyCheckForApp()) SWIG_fail;
18314         PyThreadState* __tstate = wxPyBeginAllowThreads();
18315         result = (wxClientDC *)new wxClientDC(arg1);
18316
18317         wxPyEndAllowThreads(__tstate);
18318         if (PyErr_Occurred()) SWIG_fail;
18319     }
18320     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClientDC, 1);
18321     return resultobj;
18322     fail:
18323     return NULL;
18324 }
18325
18326
18327 static PyObject * ClientDC_swigregister(PyObject *, PyObject *args) {
18328     PyObject *obj;
18329     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18330     SWIG_TypeClientData(SWIGTYPE_p_wxClientDC, obj);
18331     Py_INCREF(obj);
18332     return Py_BuildValue((char *)"");
18333 }
18334 static PyObject *_wrap_new_PaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
18335     PyObject *resultobj;
18336     wxWindow *arg1 = (wxWindow *) 0 ;
18337     wxPaintDC *result;
18338     PyObject * obj0 = 0 ;
18339     char *kwnames[] = {
18340         (char *) "win", NULL
18341     };
18342
18343     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PaintDC",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 = (wxPaintDC *)new wxPaintDC(arg1);
18350
18351         wxPyEndAllowThreads(__tstate);
18352         if (PyErr_Occurred()) SWIG_fail;
18353     }
18354     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintDC, 1);
18355     return resultobj;
18356     fail:
18357     return NULL;
18358 }
18359
18360
18361 static PyObject * PaintDC_swigregister(PyObject *, PyObject *args) {
18362     PyObject *obj;
18363     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18364     SWIG_TypeClientData(SWIGTYPE_p_wxPaintDC, obj);
18365     Py_INCREF(obj);
18366     return Py_BuildValue((char *)"");
18367 }
18368 static PyObject *_wrap_new_WindowDC(PyObject *, PyObject *args, PyObject *kwargs) {
18369     PyObject *resultobj;
18370     wxWindow *arg1 = (wxWindow *) 0 ;
18371     wxWindowDC *result;
18372     PyObject * obj0 = 0 ;
18373     char *kwnames[] = {
18374         (char *) "win", NULL
18375     };
18376
18377     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_WindowDC",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 = (wxWindowDC *)new wxWindowDC(arg1);
18384
18385         wxPyEndAllowThreads(__tstate);
18386         if (PyErr_Occurred()) SWIG_fail;
18387     }
18388     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDC, 1);
18389     return resultobj;
18390     fail:
18391     return NULL;
18392 }
18393
18394
18395 static PyObject * WindowDC_swigregister(PyObject *, PyObject *args) {
18396     PyObject *obj;
18397     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18398     SWIG_TypeClientData(SWIGTYPE_p_wxWindowDC, obj);
18399     Py_INCREF(obj);
18400     return Py_BuildValue((char *)"");
18401 }
18402 static PyObject *_wrap_new_MirrorDC(PyObject *, PyObject *args, PyObject *kwargs) {
18403     PyObject *resultobj;
18404     wxDC *arg1 = 0 ;
18405     bool arg2 ;
18406     wxMirrorDC *result;
18407     PyObject * obj0 = 0 ;
18408     PyObject * obj1 = 0 ;
18409     char *kwnames[] = {
18410         (char *) "dc",(char *) "mirror", NULL
18411     };
18412
18413     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_MirrorDC",kwnames,&obj0,&obj1)) goto fail;
18414     {
18415         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18416         if (SWIG_arg_fail(1)) SWIG_fail;
18417         if (arg1 == NULL) {
18418             SWIG_null_ref("wxDC");
18419         }
18420         if (SWIG_arg_fail(1)) SWIG_fail;
18421     }
18422     {
18423         arg2 = (bool)(SWIG_As_bool(obj1));
18424         if (SWIG_arg_fail(2)) SWIG_fail;
18425     }
18426     {
18427         if (!wxPyCheckForApp()) SWIG_fail;
18428         PyThreadState* __tstate = wxPyBeginAllowThreads();
18429         result = (wxMirrorDC *)new wxMirrorDC(*arg1,arg2);
18430
18431         wxPyEndAllowThreads(__tstate);
18432         if (PyErr_Occurred()) SWIG_fail;
18433     }
18434     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMirrorDC, 1);
18435     return resultobj;
18436     fail:
18437     return NULL;
18438 }
18439
18440
18441 static PyObject * MirrorDC_swigregister(PyObject *, PyObject *args) {
18442     PyObject *obj;
18443     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18444     SWIG_TypeClientData(SWIGTYPE_p_wxMirrorDC, obj);
18445     Py_INCREF(obj);
18446     return Py_BuildValue((char *)"");
18447 }
18448 static PyObject *_wrap_new_PostScriptDC(PyObject *, PyObject *args, PyObject *kwargs) {
18449     PyObject *resultobj;
18450     wxPrintData *arg1 = 0 ;
18451     wxPostScriptDC *result;
18452     PyObject * obj0 = 0 ;
18453     char *kwnames[] = {
18454         (char *) "printData", NULL
18455     };
18456
18457     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PostScriptDC",kwnames,&obj0)) goto fail;
18458     {
18459         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18460         if (SWIG_arg_fail(1)) SWIG_fail;
18461         if (arg1 == NULL) {
18462             SWIG_null_ref("wxPrintData");
18463         }
18464         if (SWIG_arg_fail(1)) SWIG_fail;
18465     }
18466     {
18467         if (!wxPyCheckForApp()) SWIG_fail;
18468         PyThreadState* __tstate = wxPyBeginAllowThreads();
18469         result = (wxPostScriptDC *)new wxPostScriptDC((wxPrintData const &)*arg1);
18470
18471         wxPyEndAllowThreads(__tstate);
18472         if (PyErr_Occurred()) SWIG_fail;
18473     }
18474     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPostScriptDC, 1);
18475     return resultobj;
18476     fail:
18477     return NULL;
18478 }
18479
18480
18481 static PyObject *_wrap_PostScriptDC_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
18482     PyObject *resultobj;
18483     wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
18484     wxPrintData *result;
18485     PyObject * obj0 = 0 ;
18486     char *kwnames[] = {
18487         (char *) "self", NULL
18488     };
18489
18490     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_GetPrintData",kwnames,&obj0)) goto fail;
18491     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
18492     if (SWIG_arg_fail(1)) SWIG_fail;
18493     {
18494         PyThreadState* __tstate = wxPyBeginAllowThreads();
18495         {
18496             wxPrintData &_result_ref = (arg1)->GetPrintData();
18497             result = (wxPrintData *) &_result_ref;
18498         }
18499
18500         wxPyEndAllowThreads(__tstate);
18501         if (PyErr_Occurred()) SWIG_fail;
18502     }
18503     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
18504     return resultobj;
18505     fail:
18506     return NULL;
18507 }
18508
18509
18510 static PyObject *_wrap_PostScriptDC_SetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
18511     PyObject *resultobj;
18512     wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
18513     wxPrintData *arg2 = 0 ;
18514     PyObject * obj0 = 0 ;
18515     PyObject * obj1 = 0 ;
18516     char *kwnames[] = {
18517         (char *) "self",(char *) "data", NULL
18518     };
18519
18520     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostScriptDC_SetPrintData",kwnames,&obj0,&obj1)) goto fail;
18521     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
18522     if (SWIG_arg_fail(1)) SWIG_fail;
18523     {
18524         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18525         if (SWIG_arg_fail(2)) SWIG_fail;
18526         if (arg2 == NULL) {
18527             SWIG_null_ref("wxPrintData");
18528         }
18529         if (SWIG_arg_fail(2)) SWIG_fail;
18530     }
18531     {
18532         PyThreadState* __tstate = wxPyBeginAllowThreads();
18533         (arg1)->SetPrintData((wxPrintData const &)*arg2);
18534
18535         wxPyEndAllowThreads(__tstate);
18536         if (PyErr_Occurred()) SWIG_fail;
18537     }
18538     Py_INCREF(Py_None); resultobj = Py_None;
18539     return resultobj;
18540     fail:
18541     return NULL;
18542 }
18543
18544
18545 static PyObject *_wrap_PostScriptDC_SetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
18546     PyObject *resultobj;
18547     int arg1 ;
18548     PyObject * obj0 = 0 ;
18549     char *kwnames[] = {
18550         (char *) "ppi", NULL
18551     };
18552
18553     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_SetResolution",kwnames,&obj0)) goto fail;
18554     {
18555         arg1 = (int)(SWIG_As_int(obj0));
18556         if (SWIG_arg_fail(1)) SWIG_fail;
18557     }
18558     {
18559         PyThreadState* __tstate = wxPyBeginAllowThreads();
18560         wxPostScriptDC::SetResolution(arg1);
18561
18562         wxPyEndAllowThreads(__tstate);
18563         if (PyErr_Occurred()) SWIG_fail;
18564     }
18565     Py_INCREF(Py_None); resultobj = Py_None;
18566     return resultobj;
18567     fail:
18568     return NULL;
18569 }
18570
18571
18572 static PyObject *_wrap_PostScriptDC_GetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
18573     PyObject *resultobj;
18574     int result;
18575     char *kwnames[] = {
18576         NULL
18577     };
18578
18579     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PostScriptDC_GetResolution",kwnames)) goto fail;
18580     {
18581         PyThreadState* __tstate = wxPyBeginAllowThreads();
18582         result = (int)wxPostScriptDC::GetResolution();
18583
18584         wxPyEndAllowThreads(__tstate);
18585         if (PyErr_Occurred()) SWIG_fail;
18586     }
18587     {
18588         resultobj = SWIG_From_int((int)(result));
18589     }
18590     return resultobj;
18591     fail:
18592     return NULL;
18593 }
18594
18595
18596 static PyObject * PostScriptDC_swigregister(PyObject *, PyObject *args) {
18597     PyObject *obj;
18598     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18599     SWIG_TypeClientData(SWIGTYPE_p_wxPostScriptDC, obj);
18600     Py_INCREF(obj);
18601     return Py_BuildValue((char *)"");
18602 }
18603 static PyObject *_wrap_new_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
18604     PyObject *resultobj;
18605     wxString const &arg1_defvalue = wxPyEmptyString ;
18606     wxString *arg1 = (wxString *) &arg1_defvalue ;
18607     wxMetaFile *result;
18608     bool temp1 = false ;
18609     PyObject * obj0 = 0 ;
18610     char *kwnames[] = {
18611         (char *) "filename", NULL
18612     };
18613
18614     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MetaFile",kwnames,&obj0)) goto fail;
18615     if (obj0) {
18616         {
18617             arg1 = wxString_in_helper(obj0);
18618             if (arg1 == NULL) SWIG_fail;
18619             temp1 = true;
18620         }
18621     }
18622     {
18623         if (!wxPyCheckForApp()) SWIG_fail;
18624         PyThreadState* __tstate = wxPyBeginAllowThreads();
18625         result = (wxMetaFile *)new wxMetaFile((wxString const &)*arg1);
18626
18627         wxPyEndAllowThreads(__tstate);
18628         if (PyErr_Occurred()) SWIG_fail;
18629     }
18630     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 1);
18631     {
18632         if (temp1)
18633         delete arg1;
18634     }
18635     return resultobj;
18636     fail:
18637     {
18638         if (temp1)
18639         delete arg1;
18640     }
18641     return NULL;
18642 }
18643
18644
18645 static PyObject *_wrap_delete_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
18646     PyObject *resultobj;
18647     wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18648     PyObject * obj0 = 0 ;
18649     char *kwnames[] = {
18650         (char *) "self", NULL
18651     };
18652
18653     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MetaFile",kwnames,&obj0)) goto fail;
18654     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18655     if (SWIG_arg_fail(1)) SWIG_fail;
18656     {
18657         PyThreadState* __tstate = wxPyBeginAllowThreads();
18658         delete arg1;
18659
18660         wxPyEndAllowThreads(__tstate);
18661         if (PyErr_Occurred()) SWIG_fail;
18662     }
18663     Py_INCREF(Py_None); resultobj = Py_None;
18664     return resultobj;
18665     fail:
18666     return NULL;
18667 }
18668
18669
18670 static PyObject *_wrap_MetaFile_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
18671     PyObject *resultobj;
18672     wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18673     bool result;
18674     PyObject * obj0 = 0 ;
18675     char *kwnames[] = {
18676         (char *) "self", NULL
18677     };
18678
18679     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_Ok",kwnames,&obj0)) goto fail;
18680     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18681     if (SWIG_arg_fail(1)) SWIG_fail;
18682     {
18683         PyThreadState* __tstate = wxPyBeginAllowThreads();
18684         result = (bool)(arg1)->Ok();
18685
18686         wxPyEndAllowThreads(__tstate);
18687         if (PyErr_Occurred()) SWIG_fail;
18688     }
18689     {
18690         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18691     }
18692     return resultobj;
18693     fail:
18694     return NULL;
18695 }
18696
18697
18698 static PyObject *_wrap_MetaFile_SetClipboard(PyObject *, PyObject *args, PyObject *kwargs) {
18699     PyObject *resultobj;
18700     wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18701     int arg2 = (int) 0 ;
18702     int arg3 = (int) 0 ;
18703     bool result;
18704     PyObject * obj0 = 0 ;
18705     PyObject * obj1 = 0 ;
18706     PyObject * obj2 = 0 ;
18707     char *kwnames[] = {
18708         (char *) "self",(char *) "width",(char *) "height", NULL
18709     };
18710
18711     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MetaFile_SetClipboard",kwnames,&obj0,&obj1,&obj2)) goto fail;
18712     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18713     if (SWIG_arg_fail(1)) SWIG_fail;
18714     if (obj1) {
18715         {
18716             arg2 = (int)(SWIG_As_int(obj1));
18717             if (SWIG_arg_fail(2)) SWIG_fail;
18718         }
18719     }
18720     if (obj2) {
18721         {
18722             arg3 = (int)(SWIG_As_int(obj2));
18723             if (SWIG_arg_fail(3)) SWIG_fail;
18724         }
18725     }
18726     {
18727         PyThreadState* __tstate = wxPyBeginAllowThreads();
18728         result = (bool)(arg1)->SetClipboard(arg2,arg3);
18729
18730         wxPyEndAllowThreads(__tstate);
18731         if (PyErr_Occurred()) SWIG_fail;
18732     }
18733     {
18734         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18735     }
18736     return resultobj;
18737     fail:
18738     return NULL;
18739 }
18740
18741
18742 static PyObject *_wrap_MetaFile_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18743     PyObject *resultobj;
18744     wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18745     wxSize result;
18746     PyObject * obj0 = 0 ;
18747     char *kwnames[] = {
18748         (char *) "self", NULL
18749     };
18750
18751     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetSize",kwnames,&obj0)) goto fail;
18752     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18753     if (SWIG_arg_fail(1)) SWIG_fail;
18754     {
18755         PyThreadState* __tstate = wxPyBeginAllowThreads();
18756         result = (arg1)->GetSize();
18757
18758         wxPyEndAllowThreads(__tstate);
18759         if (PyErr_Occurred()) SWIG_fail;
18760     }
18761     {
18762         wxSize * resultptr;
18763         resultptr = new wxSize((wxSize &)(result));
18764         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18765     }
18766     return resultobj;
18767     fail:
18768     return NULL;
18769 }
18770
18771
18772 static PyObject *_wrap_MetaFile_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
18773     PyObject *resultobj;
18774     wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18775     int result;
18776     PyObject * obj0 = 0 ;
18777     char *kwnames[] = {
18778         (char *) "self", NULL
18779     };
18780
18781     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetWidth",kwnames,&obj0)) goto fail;
18782     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18783     if (SWIG_arg_fail(1)) SWIG_fail;
18784     {
18785         PyThreadState* __tstate = wxPyBeginAllowThreads();
18786         result = (int)(arg1)->GetWidth();
18787
18788         wxPyEndAllowThreads(__tstate);
18789         if (PyErr_Occurred()) SWIG_fail;
18790     }
18791     {
18792         resultobj = SWIG_From_int((int)(result));
18793     }
18794     return resultobj;
18795     fail:
18796     return NULL;
18797 }
18798
18799
18800 static PyObject *_wrap_MetaFile_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
18801     PyObject *resultobj;
18802     wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18803     int result;
18804     PyObject * obj0 = 0 ;
18805     char *kwnames[] = {
18806         (char *) "self", NULL
18807     };
18808
18809     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetHeight",kwnames,&obj0)) goto fail;
18810     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18811     if (SWIG_arg_fail(1)) SWIG_fail;
18812     {
18813         PyThreadState* __tstate = wxPyBeginAllowThreads();
18814         result = (int)(arg1)->GetHeight();
18815
18816         wxPyEndAllowThreads(__tstate);
18817         if (PyErr_Occurred()) SWIG_fail;
18818     }
18819     {
18820         resultobj = SWIG_From_int((int)(result));
18821     }
18822     return resultobj;
18823     fail:
18824     return NULL;
18825 }
18826
18827
18828 static PyObject *_wrap_MetaFile_GetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
18829     PyObject *resultobj;
18830     wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18831     wxString *result;
18832     PyObject * obj0 = 0 ;
18833     char *kwnames[] = {
18834         (char *) "self", NULL
18835     };
18836
18837     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetFileName",kwnames,&obj0)) goto fail;
18838     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18839     if (SWIG_arg_fail(1)) SWIG_fail;
18840     {
18841         PyThreadState* __tstate = wxPyBeginAllowThreads();
18842         {
18843             wxString const &_result_ref = ((wxMetaFile const *)arg1)->GetFileName();
18844             result = (wxString *) &_result_ref;
18845         }
18846
18847         wxPyEndAllowThreads(__tstate);
18848         if (PyErr_Occurred()) SWIG_fail;
18849     }
18850     {
18851 #if wxUSE_UNICODE
18852         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18853 #else
18854         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18855 #endif
18856     }
18857     return resultobj;
18858     fail:
18859     return NULL;
18860 }
18861
18862
18863 static PyObject * MetaFile_swigregister(PyObject *, PyObject *args) {
18864     PyObject *obj;
18865     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18866     SWIG_TypeClientData(SWIGTYPE_p_wxMetaFile, obj);
18867     Py_INCREF(obj);
18868     return Py_BuildValue((char *)"");
18869 }
18870 static PyObject *_wrap_new_MetaFileDC(PyObject *, PyObject *args, PyObject *kwargs) {
18871     PyObject *resultobj;
18872     wxString const &arg1_defvalue = wxPyEmptyString ;
18873     wxString *arg1 = (wxString *) &arg1_defvalue ;
18874     int arg2 = (int) 0 ;
18875     int arg3 = (int) 0 ;
18876     wxString const &arg4_defvalue = wxPyEmptyString ;
18877     wxString *arg4 = (wxString *) &arg4_defvalue ;
18878     wxMetaFileDC *result;
18879     bool temp1 = false ;
18880     bool temp4 = false ;
18881     PyObject * obj0 = 0 ;
18882     PyObject * obj1 = 0 ;
18883     PyObject * obj2 = 0 ;
18884     PyObject * obj3 = 0 ;
18885     char *kwnames[] = {
18886         (char *) "filename",(char *) "width",(char *) "height",(char *) "description", NULL
18887     };
18888
18889     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_MetaFileDC",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18890     if (obj0) {
18891         {
18892             arg1 = wxString_in_helper(obj0);
18893             if (arg1 == NULL) SWIG_fail;
18894             temp1 = true;
18895         }
18896     }
18897     if (obj1) {
18898         {
18899             arg2 = (int)(SWIG_As_int(obj1));
18900             if (SWIG_arg_fail(2)) SWIG_fail;
18901         }
18902     }
18903     if (obj2) {
18904         {
18905             arg3 = (int)(SWIG_As_int(obj2));
18906             if (SWIG_arg_fail(3)) SWIG_fail;
18907         }
18908     }
18909     if (obj3) {
18910         {
18911             arg4 = wxString_in_helper(obj3);
18912             if (arg4 == NULL) SWIG_fail;
18913             temp4 = true;
18914         }
18915     }
18916     {
18917         if (!wxPyCheckForApp()) SWIG_fail;
18918         PyThreadState* __tstate = wxPyBeginAllowThreads();
18919         result = (wxMetaFileDC *)new wxMetaFileDC((wxString const &)*arg1,arg2,arg3,(wxString const &)*arg4);
18920
18921         wxPyEndAllowThreads(__tstate);
18922         if (PyErr_Occurred()) SWIG_fail;
18923     }
18924     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFileDC, 1);
18925     {
18926         if (temp1)
18927         delete arg1;
18928     }
18929     {
18930         if (temp4)
18931         delete arg4;
18932     }
18933     return resultobj;
18934     fail:
18935     {
18936         if (temp1)
18937         delete arg1;
18938     }
18939     {
18940         if (temp4)
18941         delete arg4;
18942     }
18943     return NULL;
18944 }
18945
18946
18947 static PyObject *_wrap_MetaFileDC_Close(PyObject *, PyObject *args, PyObject *kwargs) {
18948     PyObject *resultobj;
18949     wxMetaFileDC *arg1 = (wxMetaFileDC *) 0 ;
18950     wxMetaFile *result;
18951     PyObject * obj0 = 0 ;
18952     char *kwnames[] = {
18953         (char *) "self", NULL
18954     };
18955
18956     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFileDC_Close",kwnames,&obj0)) goto fail;
18957     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFileDC, SWIG_POINTER_EXCEPTION | 0);
18958     if (SWIG_arg_fail(1)) SWIG_fail;
18959     {
18960         PyThreadState* __tstate = wxPyBeginAllowThreads();
18961         result = (wxMetaFile *)(arg1)->Close();
18962
18963         wxPyEndAllowThreads(__tstate);
18964         if (PyErr_Occurred()) SWIG_fail;
18965     }
18966     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 0);
18967     return resultobj;
18968     fail:
18969     return NULL;
18970 }
18971
18972
18973 static PyObject * MetaFileDC_swigregister(PyObject *, PyObject *args) {
18974     PyObject *obj;
18975     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18976     SWIG_TypeClientData(SWIGTYPE_p_wxMetaFileDC, obj);
18977     Py_INCREF(obj);
18978     return Py_BuildValue((char *)"");
18979 }
18980 static PyObject *_wrap_new_PrinterDC(PyObject *, PyObject *args, PyObject *kwargs) {
18981     PyObject *resultobj;
18982     wxPrintData *arg1 = 0 ;
18983     wxPrinterDC *result;
18984     PyObject * obj0 = 0 ;
18985     char *kwnames[] = {
18986         (char *) "printData", NULL
18987     };
18988
18989     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PrinterDC",kwnames,&obj0)) goto fail;
18990     {
18991         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18992         if (SWIG_arg_fail(1)) SWIG_fail;
18993         if (arg1 == NULL) {
18994             SWIG_null_ref("wxPrintData");
18995         }
18996         if (SWIG_arg_fail(1)) SWIG_fail;
18997     }
18998     {
18999         if (!wxPyCheckForApp()) SWIG_fail;
19000         PyThreadState* __tstate = wxPyBeginAllowThreads();
19001         result = (wxPrinterDC *)new wxPrinterDC((wxPrintData const &)*arg1);
19002
19003         wxPyEndAllowThreads(__tstate);
19004         if (PyErr_Occurred()) SWIG_fail;
19005     }
19006     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrinterDC, 1);
19007     return resultobj;
19008     fail:
19009     return NULL;
19010 }
19011
19012
19013 static PyObject * PrinterDC_swigregister(PyObject *, PyObject *args) {
19014     PyObject *obj;
19015     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19016     SWIG_TypeClientData(SWIGTYPE_p_wxPrinterDC, obj);
19017     Py_INCREF(obj);
19018     return Py_BuildValue((char *)"");
19019 }
19020 static PyObject *_wrap_new_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
19021     PyObject *resultobj;
19022     int arg1 ;
19023     int arg2 ;
19024     int arg3 = (int) true ;
19025     int arg4 = (int) 1 ;
19026     wxImageList *result;
19027     PyObject * obj0 = 0 ;
19028     PyObject * obj1 = 0 ;
19029     PyObject * obj2 = 0 ;
19030     PyObject * obj3 = 0 ;
19031     char *kwnames[] = {
19032         (char *) "width",(char *) "height",(char *) "mask",(char *) "initialCount", NULL
19033     };
19034
19035     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_ImageList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19036     {
19037         arg1 = (int)(SWIG_As_int(obj0));
19038         if (SWIG_arg_fail(1)) SWIG_fail;
19039     }
19040     {
19041         arg2 = (int)(SWIG_As_int(obj1));
19042         if (SWIG_arg_fail(2)) SWIG_fail;
19043     }
19044     if (obj2) {
19045         {
19046             arg3 = (int)(SWIG_As_int(obj2));
19047             if (SWIG_arg_fail(3)) SWIG_fail;
19048         }
19049     }
19050     if (obj3) {
19051         {
19052             arg4 = (int)(SWIG_As_int(obj3));
19053             if (SWIG_arg_fail(4)) SWIG_fail;
19054         }
19055     }
19056     {
19057         if (!wxPyCheckForApp()) SWIG_fail;
19058         PyThreadState* __tstate = wxPyBeginAllowThreads();
19059         result = (wxImageList *)new wxImageList(arg1,arg2,arg3,arg4);
19060
19061         wxPyEndAllowThreads(__tstate);
19062         if (PyErr_Occurred()) SWIG_fail;
19063     }
19064     {
19065         resultobj = wxPyMake_wxObject(result, 1);
19066     }
19067     return resultobj;
19068     fail:
19069     return NULL;
19070 }
19071
19072
19073 static PyObject *_wrap_delete_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
19074     PyObject *resultobj;
19075     wxImageList *arg1 = (wxImageList *) 0 ;
19076     PyObject * obj0 = 0 ;
19077     char *kwnames[] = {
19078         (char *) "self", NULL
19079     };
19080
19081     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ImageList",kwnames,&obj0)) goto fail;
19082     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19083     if (SWIG_arg_fail(1)) SWIG_fail;
19084     {
19085         PyThreadState* __tstate = wxPyBeginAllowThreads();
19086         delete arg1;
19087
19088         wxPyEndAllowThreads(__tstate);
19089         if (PyErr_Occurred()) SWIG_fail;
19090     }
19091     Py_INCREF(Py_None); resultobj = Py_None;
19092     return resultobj;
19093     fail:
19094     return NULL;
19095 }
19096
19097
19098 static PyObject *_wrap_ImageList_Add(PyObject *, PyObject *args, PyObject *kwargs) {
19099     PyObject *resultobj;
19100     wxImageList *arg1 = (wxImageList *) 0 ;
19101     wxBitmap *arg2 = 0 ;
19102     wxBitmap const &arg3_defvalue = wxNullBitmap ;
19103     wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
19104     int result;
19105     PyObject * obj0 = 0 ;
19106     PyObject * obj1 = 0 ;
19107     PyObject * obj2 = 0 ;
19108     char *kwnames[] = {
19109         (char *) "self",(char *) "bitmap",(char *) "mask", NULL
19110     };
19111
19112     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ImageList_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
19113     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19114     if (SWIG_arg_fail(1)) SWIG_fail;
19115     {
19116         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19117         if (SWIG_arg_fail(2)) SWIG_fail;
19118         if (arg2 == NULL) {
19119             SWIG_null_ref("wxBitmap");
19120         }
19121         if (SWIG_arg_fail(2)) SWIG_fail;
19122     }
19123     if (obj2) {
19124         {
19125             SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19126             if (SWIG_arg_fail(3)) SWIG_fail;
19127             if (arg3 == NULL) {
19128                 SWIG_null_ref("wxBitmap");
19129             }
19130             if (SWIG_arg_fail(3)) SWIG_fail;
19131         }
19132     }
19133     {
19134         PyThreadState* __tstate = wxPyBeginAllowThreads();
19135         result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
19136
19137         wxPyEndAllowThreads(__tstate);
19138         if (PyErr_Occurred()) SWIG_fail;
19139     }
19140     {
19141         resultobj = SWIG_From_int((int)(result));
19142     }
19143     return resultobj;
19144     fail:
19145     return NULL;
19146 }
19147
19148
19149 static PyObject *_wrap_ImageList_AddWithColourMask(PyObject *, PyObject *args, PyObject *kwargs) {
19150     PyObject *resultobj;
19151     wxImageList *arg1 = (wxImageList *) 0 ;
19152     wxBitmap *arg2 = 0 ;
19153     wxColour *arg3 = 0 ;
19154     int result;
19155     wxColour temp3 ;
19156     PyObject * obj0 = 0 ;
19157     PyObject * obj1 = 0 ;
19158     PyObject * obj2 = 0 ;
19159     char *kwnames[] = {
19160         (char *) "self",(char *) "bitmap",(char *) "maskColour", NULL
19161     };
19162
19163     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_AddWithColourMask",kwnames,&obj0,&obj1,&obj2)) goto fail;
19164     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19165     if (SWIG_arg_fail(1)) SWIG_fail;
19166     {
19167         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19168         if (SWIG_arg_fail(2)) SWIG_fail;
19169         if (arg2 == NULL) {
19170             SWIG_null_ref("wxBitmap");
19171         }
19172         if (SWIG_arg_fail(2)) SWIG_fail;
19173     }
19174     {
19175         arg3 = &temp3;
19176         if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
19177     }
19178     {
19179         PyThreadState* __tstate = wxPyBeginAllowThreads();
19180         result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxColour const &)*arg3);
19181
19182         wxPyEndAllowThreads(__tstate);
19183         if (PyErr_Occurred()) SWIG_fail;
19184     }
19185     {
19186         resultobj = SWIG_From_int((int)(result));
19187     }
19188     return resultobj;
19189     fail:
19190     return NULL;
19191 }
19192
19193
19194 static PyObject *_wrap_ImageList_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
19195     PyObject *resultobj;
19196     wxImageList *arg1 = (wxImageList *) 0 ;
19197     wxIcon *arg2 = 0 ;
19198     int result;
19199     PyObject * obj0 = 0 ;
19200     PyObject * obj1 = 0 ;
19201     char *kwnames[] = {
19202         (char *) "self",(char *) "icon", NULL
19203     };
19204
19205     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_AddIcon",kwnames,&obj0,&obj1)) goto fail;
19206     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19207     if (SWIG_arg_fail(1)) SWIG_fail;
19208     {
19209         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
19210         if (SWIG_arg_fail(2)) SWIG_fail;
19211         if (arg2 == NULL) {
19212             SWIG_null_ref("wxIcon");
19213         }
19214         if (SWIG_arg_fail(2)) SWIG_fail;
19215     }
19216     {
19217         PyThreadState* __tstate = wxPyBeginAllowThreads();
19218         result = (int)(arg1)->Add((wxIcon const &)*arg2);
19219
19220         wxPyEndAllowThreads(__tstate);
19221         if (PyErr_Occurred()) SWIG_fail;
19222     }
19223     {
19224         resultobj = SWIG_From_int((int)(result));
19225     }
19226     return resultobj;
19227     fail:
19228     return NULL;
19229 }
19230
19231
19232 static PyObject *_wrap_ImageList_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
19233     PyObject *resultobj;
19234     wxImageList *arg1 = (wxImageList *) 0 ;
19235     int arg2 ;
19236     SwigValueWrapper<wxBitmap > result;
19237     PyObject * obj0 = 0 ;
19238     PyObject * obj1 = 0 ;
19239     char *kwnames[] = {
19240         (char *) "self",(char *) "index", NULL
19241     };
19242
19243     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetBitmap",kwnames,&obj0,&obj1)) goto fail;
19244     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19245     if (SWIG_arg_fail(1)) SWIG_fail;
19246     {
19247         arg2 = (int)(SWIG_As_int(obj1));
19248         if (SWIG_arg_fail(2)) SWIG_fail;
19249     }
19250     {
19251         PyThreadState* __tstate = wxPyBeginAllowThreads();
19252         result = ((wxImageList const *)arg1)->GetBitmap(arg2);
19253
19254         wxPyEndAllowThreads(__tstate);
19255         if (PyErr_Occurred()) SWIG_fail;
19256     }
19257     {
19258         wxBitmap * resultptr;
19259         resultptr = new wxBitmap((wxBitmap &)(result));
19260         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
19261     }
19262     return resultobj;
19263     fail:
19264     return NULL;
19265 }
19266
19267
19268 static PyObject *_wrap_ImageList_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
19269     PyObject *resultobj;
19270     wxImageList *arg1 = (wxImageList *) 0 ;
19271     int arg2 ;
19272     wxIcon result;
19273     PyObject * obj0 = 0 ;
19274     PyObject * obj1 = 0 ;
19275     char *kwnames[] = {
19276         (char *) "self",(char *) "index", NULL
19277     };
19278
19279     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetIcon",kwnames,&obj0,&obj1)) goto fail;
19280     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19281     if (SWIG_arg_fail(1)) SWIG_fail;
19282     {
19283         arg2 = (int)(SWIG_As_int(obj1));
19284         if (SWIG_arg_fail(2)) SWIG_fail;
19285     }
19286     {
19287         PyThreadState* __tstate = wxPyBeginAllowThreads();
19288         result = ((wxImageList const *)arg1)->GetIcon(arg2);
19289
19290         wxPyEndAllowThreads(__tstate);
19291         if (PyErr_Occurred()) SWIG_fail;
19292     }
19293     {
19294         wxIcon * resultptr;
19295         resultptr = new wxIcon((wxIcon &)(result));
19296         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
19297     }
19298     return resultobj;
19299     fail:
19300     return NULL;
19301 }
19302
19303
19304 static PyObject *_wrap_ImageList_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
19305     PyObject *resultobj;
19306     wxImageList *arg1 = (wxImageList *) 0 ;
19307     int arg2 ;
19308     wxBitmap *arg3 = 0 ;
19309     wxBitmap const &arg4_defvalue = wxNullBitmap ;
19310     wxBitmap *arg4 = (wxBitmap *) &arg4_defvalue ;
19311     bool result;
19312     PyObject * obj0 = 0 ;
19313     PyObject * obj1 = 0 ;
19314     PyObject * obj2 = 0 ;
19315     PyObject * obj3 = 0 ;
19316     char *kwnames[] = {
19317         (char *) "self",(char *) "index",(char *) "bitmap",(char *) "mask", NULL
19318     };
19319
19320     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ImageList_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19321     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19322     if (SWIG_arg_fail(1)) SWIG_fail;
19323     {
19324         arg2 = (int)(SWIG_As_int(obj1));
19325         if (SWIG_arg_fail(2)) SWIG_fail;
19326     }
19327     {
19328         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19329         if (SWIG_arg_fail(3)) SWIG_fail;
19330         if (arg3 == NULL) {
19331             SWIG_null_ref("wxBitmap");
19332         }
19333         if (SWIG_arg_fail(3)) SWIG_fail;
19334     }
19335     if (obj3) {
19336         {
19337             SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19338             if (SWIG_arg_fail(4)) SWIG_fail;
19339             if (arg4 == NULL) {
19340                 SWIG_null_ref("wxBitmap");
19341             }
19342             if (SWIG_arg_fail(4)) SWIG_fail;
19343         }
19344     }
19345     {
19346         PyThreadState* __tstate = wxPyBeginAllowThreads();
19347         result = (bool)(arg1)->Replace(arg2,(wxBitmap const &)*arg3,(wxBitmap const &)*arg4);
19348
19349         wxPyEndAllowThreads(__tstate);
19350         if (PyErr_Occurred()) SWIG_fail;
19351     }
19352     {
19353         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19354     }
19355     return resultobj;
19356     fail:
19357     return NULL;
19358 }
19359
19360
19361 static PyObject *_wrap_ImageList_Draw(PyObject *, PyObject *args, PyObject *kwargs) {
19362     PyObject *resultobj;
19363     wxImageList *arg1 = (wxImageList *) 0 ;
19364     int arg2 ;
19365     wxDC *arg3 = 0 ;
19366     int arg4 ;
19367     int arg5 ;
19368     int arg6 = (int) wxIMAGELIST_DRAW_NORMAL ;
19369     bool arg7 = (bool) (bool)false ;
19370     bool result;
19371     PyObject * obj0 = 0 ;
19372     PyObject * obj1 = 0 ;
19373     PyObject * obj2 = 0 ;
19374     PyObject * obj3 = 0 ;
19375     PyObject * obj4 = 0 ;
19376     PyObject * obj5 = 0 ;
19377     PyObject * obj6 = 0 ;
19378     char *kwnames[] = {
19379         (char *) "self",(char *) "index",(char *) "dc",(char *) "x",(char *) "x",(char *) "flags",(char *) "solidBackground", NULL
19380     };
19381
19382     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OO:ImageList_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19383     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19384     if (SWIG_arg_fail(1)) SWIG_fail;
19385     {
19386         arg2 = (int)(SWIG_As_int(obj1));
19387         if (SWIG_arg_fail(2)) SWIG_fail;
19388     }
19389     {
19390         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19391         if (SWIG_arg_fail(3)) SWIG_fail;
19392         if (arg3 == NULL) {
19393             SWIG_null_ref("wxDC");
19394         }
19395         if (SWIG_arg_fail(3)) SWIG_fail;
19396     }
19397     {
19398         arg4 = (int)(SWIG_As_int(obj3));
19399         if (SWIG_arg_fail(4)) SWIG_fail;
19400     }
19401     {
19402         arg5 = (int)(SWIG_As_int(obj4));
19403         if (SWIG_arg_fail(5)) SWIG_fail;
19404     }
19405     if (obj5) {
19406         {
19407             arg6 = (int)(SWIG_As_int(obj5));
19408             if (SWIG_arg_fail(6)) SWIG_fail;
19409         }
19410     }
19411     if (obj6) {
19412         {
19413             arg7 = (bool const)(SWIG_As_bool(obj6));
19414             if (SWIG_arg_fail(7)) SWIG_fail;
19415         }
19416     }
19417     {
19418         PyThreadState* __tstate = wxPyBeginAllowThreads();
19419         result = (bool)(arg1)->Draw(arg2,*arg3,arg4,arg5,arg6,arg7);
19420
19421         wxPyEndAllowThreads(__tstate);
19422         if (PyErr_Occurred()) SWIG_fail;
19423     }
19424     {
19425         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19426     }
19427     return resultobj;
19428     fail:
19429     return NULL;
19430 }
19431
19432
19433 static PyObject *_wrap_ImageList_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
19434     PyObject *resultobj;
19435     wxImageList *arg1 = (wxImageList *) 0 ;
19436     int result;
19437     PyObject * obj0 = 0 ;
19438     char *kwnames[] = {
19439         (char *) "self", NULL
19440     };
19441
19442     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_GetImageCount",kwnames,&obj0)) goto fail;
19443     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19444     if (SWIG_arg_fail(1)) SWIG_fail;
19445     {
19446         PyThreadState* __tstate = wxPyBeginAllowThreads();
19447         result = (int)(arg1)->GetImageCount();
19448
19449         wxPyEndAllowThreads(__tstate);
19450         if (PyErr_Occurred()) SWIG_fail;
19451     }
19452     {
19453         resultobj = SWIG_From_int((int)(result));
19454     }
19455     return resultobj;
19456     fail:
19457     return NULL;
19458 }
19459
19460
19461 static PyObject *_wrap_ImageList_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
19462     PyObject *resultobj;
19463     wxImageList *arg1 = (wxImageList *) 0 ;
19464     int arg2 ;
19465     bool result;
19466     PyObject * obj0 = 0 ;
19467     PyObject * obj1 = 0 ;
19468     char *kwnames[] = {
19469         (char *) "self",(char *) "index", NULL
19470     };
19471
19472     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_Remove",kwnames,&obj0,&obj1)) goto fail;
19473     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19474     if (SWIG_arg_fail(1)) SWIG_fail;
19475     {
19476         arg2 = (int)(SWIG_As_int(obj1));
19477         if (SWIG_arg_fail(2)) SWIG_fail;
19478     }
19479     {
19480         PyThreadState* __tstate = wxPyBeginAllowThreads();
19481         result = (bool)(arg1)->Remove(arg2);
19482
19483         wxPyEndAllowThreads(__tstate);
19484         if (PyErr_Occurred()) SWIG_fail;
19485     }
19486     {
19487         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19488     }
19489     return resultobj;
19490     fail:
19491     return NULL;
19492 }
19493
19494
19495 static PyObject *_wrap_ImageList_RemoveAll(PyObject *, PyObject *args, PyObject *kwargs) {
19496     PyObject *resultobj;
19497     wxImageList *arg1 = (wxImageList *) 0 ;
19498     bool result;
19499     PyObject * obj0 = 0 ;
19500     char *kwnames[] = {
19501         (char *) "self", NULL
19502     };
19503
19504     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_RemoveAll",kwnames,&obj0)) goto fail;
19505     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19506     if (SWIG_arg_fail(1)) SWIG_fail;
19507     {
19508         PyThreadState* __tstate = wxPyBeginAllowThreads();
19509         result = (bool)(arg1)->RemoveAll();
19510
19511         wxPyEndAllowThreads(__tstate);
19512         if (PyErr_Occurred()) SWIG_fail;
19513     }
19514     {
19515         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19516     }
19517     return resultobj;
19518     fail:
19519     return NULL;
19520 }
19521
19522
19523 static PyObject *_wrap_ImageList_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19524     PyObject *resultobj;
19525     wxImageList *arg1 = (wxImageList *) 0 ;
19526     int arg2 ;
19527     int *arg3 = 0 ;
19528     int *arg4 = 0 ;
19529     int temp3 ;
19530     int res3 = 0 ;
19531     int temp4 ;
19532     int res4 = 0 ;
19533     PyObject * obj0 = 0 ;
19534     PyObject * obj1 = 0 ;
19535     char *kwnames[] = {
19536         (char *) "self",(char *) "index", NULL
19537     };
19538
19539     arg3 = &temp3; res3 = SWIG_NEWOBJ;
19540     arg4 = &temp4; res4 = SWIG_NEWOBJ;
19541     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetSize",kwnames,&obj0,&obj1)) goto fail;
19542     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19543     if (SWIG_arg_fail(1)) SWIG_fail;
19544     {
19545         arg2 = (int)(SWIG_As_int(obj1));
19546         if (SWIG_arg_fail(2)) SWIG_fail;
19547     }
19548     {
19549         PyThreadState* __tstate = wxPyBeginAllowThreads();
19550         (arg1)->GetSize(arg2,*arg3,*arg4);
19551
19552         wxPyEndAllowThreads(__tstate);
19553         if (PyErr_Occurred()) SWIG_fail;
19554     }
19555     Py_INCREF(Py_None); resultobj = Py_None;
19556     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19557     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
19558     resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
19559     SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
19560     return resultobj;
19561     fail:
19562     return NULL;
19563 }
19564
19565
19566 static PyObject * ImageList_swigregister(PyObject *, PyObject *args) {
19567     PyObject *obj;
19568     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19569     SWIG_TypeClientData(SWIGTYPE_p_wxImageList, obj);
19570     Py_INCREF(obj);
19571     return Py_BuildValue((char *)"");
19572 }
19573 static int _wrap_NORMAL_FONT_set(PyObject *) {
19574     PyErr_SetString(PyExc_TypeError,"Variable NORMAL_FONT is read-only.");
19575     return 1;
19576 }
19577
19578
19579 static PyObject *_wrap_NORMAL_FONT_get(void) {
19580     PyObject *pyobj;
19581
19582     pyobj = SWIG_NewPointerObj((void *)(wxNORMAL_FONT), SWIGTYPE_p_wxFont, 0);
19583     return pyobj;
19584 }
19585
19586
19587 static int _wrap_SMALL_FONT_set(PyObject *) {
19588     PyErr_SetString(PyExc_TypeError,"Variable SMALL_FONT is read-only.");
19589     return 1;
19590 }
19591
19592
19593 static PyObject *_wrap_SMALL_FONT_get(void) {
19594     PyObject *pyobj;
19595
19596     pyobj = SWIG_NewPointerObj((void *)(wxSMALL_FONT), SWIGTYPE_p_wxFont, 0);
19597     return pyobj;
19598 }
19599
19600
19601 static int _wrap_ITALIC_FONT_set(PyObject *) {
19602     PyErr_SetString(PyExc_TypeError,"Variable ITALIC_FONT is read-only.");
19603     return 1;
19604 }
19605
19606
19607 static PyObject *_wrap_ITALIC_FONT_get(void) {
19608     PyObject *pyobj;
19609
19610     pyobj = SWIG_NewPointerObj((void *)(wxITALIC_FONT), SWIGTYPE_p_wxFont, 0);
19611     return pyobj;
19612 }
19613
19614
19615 static int _wrap_SWISS_FONT_set(PyObject *) {
19616     PyErr_SetString(PyExc_TypeError,"Variable SWISS_FONT is read-only.");
19617     return 1;
19618 }
19619
19620
19621 static PyObject *_wrap_SWISS_FONT_get(void) {
19622     PyObject *pyobj;
19623
19624     pyobj = SWIG_NewPointerObj((void *)(wxSWISS_FONT), SWIGTYPE_p_wxFont, 0);
19625     return pyobj;
19626 }
19627
19628
19629 static int _wrap_RED_PEN_set(PyObject *) {
19630     PyErr_SetString(PyExc_TypeError,"Variable RED_PEN is read-only.");
19631     return 1;
19632 }
19633
19634
19635 static PyObject *_wrap_RED_PEN_get(void) {
19636     PyObject *pyobj;
19637
19638     pyobj = SWIG_NewPointerObj((void *)(wxRED_PEN), SWIGTYPE_p_wxPen, 0);
19639     return pyobj;
19640 }
19641
19642
19643 static int _wrap_CYAN_PEN_set(PyObject *) {
19644     PyErr_SetString(PyExc_TypeError,"Variable CYAN_PEN is read-only.");
19645     return 1;
19646 }
19647
19648
19649 static PyObject *_wrap_CYAN_PEN_get(void) {
19650     PyObject *pyobj;
19651
19652     pyobj = SWIG_NewPointerObj((void *)(wxCYAN_PEN), SWIGTYPE_p_wxPen, 0);
19653     return pyobj;
19654 }
19655
19656
19657 static int _wrap_GREEN_PEN_set(PyObject *) {
19658     PyErr_SetString(PyExc_TypeError,"Variable GREEN_PEN is read-only.");
19659     return 1;
19660 }
19661
19662
19663 static PyObject *_wrap_GREEN_PEN_get(void) {
19664     PyObject *pyobj;
19665
19666     pyobj = SWIG_NewPointerObj((void *)(wxGREEN_PEN), SWIGTYPE_p_wxPen, 0);
19667     return pyobj;
19668 }
19669
19670
19671 static int _wrap_BLACK_PEN_set(PyObject *) {
19672     PyErr_SetString(PyExc_TypeError,"Variable BLACK_PEN is read-only.");
19673     return 1;
19674 }
19675
19676
19677 static PyObject *_wrap_BLACK_PEN_get(void) {
19678     PyObject *pyobj;
19679
19680     pyobj = SWIG_NewPointerObj((void *)(wxBLACK_PEN), SWIGTYPE_p_wxPen, 0);
19681     return pyobj;
19682 }
19683
19684
19685 static int _wrap_WHITE_PEN_set(PyObject *) {
19686     PyErr_SetString(PyExc_TypeError,"Variable WHITE_PEN is read-only.");
19687     return 1;
19688 }
19689
19690
19691 static PyObject *_wrap_WHITE_PEN_get(void) {
19692     PyObject *pyobj;
19693
19694     pyobj = SWIG_NewPointerObj((void *)(wxWHITE_PEN), SWIGTYPE_p_wxPen, 0);
19695     return pyobj;
19696 }
19697
19698
19699 static int _wrap_TRANSPARENT_PEN_set(PyObject *) {
19700     PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_PEN is read-only.");
19701     return 1;
19702 }
19703
19704
19705 static PyObject *_wrap_TRANSPARENT_PEN_get(void) {
19706     PyObject *pyobj;
19707
19708     pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_PEN), SWIGTYPE_p_wxPen, 0);
19709     return pyobj;
19710 }
19711
19712
19713 static int _wrap_BLACK_DASHED_PEN_set(PyObject *) {
19714     PyErr_SetString(PyExc_TypeError,"Variable BLACK_DASHED_PEN is read-only.");
19715     return 1;
19716 }
19717
19718
19719 static PyObject *_wrap_BLACK_DASHED_PEN_get(void) {
19720     PyObject *pyobj;
19721
19722     pyobj = SWIG_NewPointerObj((void *)(wxBLACK_DASHED_PEN), SWIGTYPE_p_wxPen, 0);
19723     return pyobj;
19724 }
19725
19726
19727 static int _wrap_GREY_PEN_set(PyObject *) {
19728     PyErr_SetString(PyExc_TypeError,"Variable GREY_PEN is read-only.");
19729     return 1;
19730 }
19731
19732
19733 static PyObject *_wrap_GREY_PEN_get(void) {
19734     PyObject *pyobj;
19735
19736     pyobj = SWIG_NewPointerObj((void *)(wxGREY_PEN), SWIGTYPE_p_wxPen, 0);
19737     return pyobj;
19738 }
19739
19740
19741 static int _wrap_MEDIUM_GREY_PEN_set(PyObject *) {
19742     PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_PEN is read-only.");
19743     return 1;
19744 }
19745
19746
19747 static PyObject *_wrap_MEDIUM_GREY_PEN_get(void) {
19748     PyObject *pyobj;
19749
19750     pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_PEN), SWIGTYPE_p_wxPen, 0);
19751     return pyobj;
19752 }
19753
19754
19755 static int _wrap_LIGHT_GREY_PEN_set(PyObject *) {
19756     PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_PEN is read-only.");
19757     return 1;
19758 }
19759
19760
19761 static PyObject *_wrap_LIGHT_GREY_PEN_get(void) {
19762     PyObject *pyobj;
19763
19764     pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_PEN), SWIGTYPE_p_wxPen, 0);
19765     return pyobj;
19766 }
19767
19768
19769 static int _wrap_BLUE_BRUSH_set(PyObject *) {
19770     PyErr_SetString(PyExc_TypeError,"Variable BLUE_BRUSH is read-only.");
19771     return 1;
19772 }
19773
19774
19775 static PyObject *_wrap_BLUE_BRUSH_get(void) {
19776     PyObject *pyobj;
19777
19778     pyobj = SWIG_NewPointerObj((void *)(wxBLUE_BRUSH), SWIGTYPE_p_wxBrush, 0);
19779     return pyobj;
19780 }
19781
19782
19783 static int _wrap_GREEN_BRUSH_set(PyObject *) {
19784     PyErr_SetString(PyExc_TypeError,"Variable GREEN_BRUSH is read-only.");
19785     return 1;
19786 }
19787
19788
19789 static PyObject *_wrap_GREEN_BRUSH_get(void) {
19790     PyObject *pyobj;
19791
19792     pyobj = SWIG_NewPointerObj((void *)(wxGREEN_BRUSH), SWIGTYPE_p_wxBrush, 0);
19793     return pyobj;
19794 }
19795
19796
19797 static int _wrap_WHITE_BRUSH_set(PyObject *) {
19798     PyErr_SetString(PyExc_TypeError,"Variable WHITE_BRUSH is read-only.");
19799     return 1;
19800 }
19801
19802
19803 static PyObject *_wrap_WHITE_BRUSH_get(void) {
19804     PyObject *pyobj;
19805
19806     pyobj = SWIG_NewPointerObj((void *)(wxWHITE_BRUSH), SWIGTYPE_p_wxBrush, 0);
19807     return pyobj;
19808 }
19809
19810
19811 static int _wrap_BLACK_BRUSH_set(PyObject *) {
19812     PyErr_SetString(PyExc_TypeError,"Variable BLACK_BRUSH is read-only.");
19813     return 1;
19814 }
19815
19816
19817 static PyObject *_wrap_BLACK_BRUSH_get(void) {
19818     PyObject *pyobj;
19819
19820     pyobj = SWIG_NewPointerObj((void *)(wxBLACK_BRUSH), SWIGTYPE_p_wxBrush, 0);
19821     return pyobj;
19822 }
19823
19824
19825 static int _wrap_TRANSPARENT_BRUSH_set(PyObject *) {
19826     PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_BRUSH is read-only.");
19827     return 1;
19828 }
19829
19830
19831 static PyObject *_wrap_TRANSPARENT_BRUSH_get(void) {
19832     PyObject *pyobj;
19833
19834     pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_BRUSH), SWIGTYPE_p_wxBrush, 0);
19835     return pyobj;
19836 }
19837
19838
19839 static int _wrap_CYAN_BRUSH_set(PyObject *) {
19840     PyErr_SetString(PyExc_TypeError,"Variable CYAN_BRUSH is read-only.");
19841     return 1;
19842 }
19843
19844
19845 static PyObject *_wrap_CYAN_BRUSH_get(void) {
19846     PyObject *pyobj;
19847
19848     pyobj = SWIG_NewPointerObj((void *)(wxCYAN_BRUSH), SWIGTYPE_p_wxBrush, 0);
19849     return pyobj;
19850 }
19851
19852
19853 static int _wrap_RED_BRUSH_set(PyObject *) {
19854     PyErr_SetString(PyExc_TypeError,"Variable RED_BRUSH is read-only.");
19855     return 1;
19856 }
19857
19858
19859 static PyObject *_wrap_RED_BRUSH_get(void) {
19860     PyObject *pyobj;
19861
19862     pyobj = SWIG_NewPointerObj((void *)(wxRED_BRUSH), SWIGTYPE_p_wxBrush, 0);
19863     return pyobj;
19864 }
19865
19866
19867 static int _wrap_GREY_BRUSH_set(PyObject *) {
19868     PyErr_SetString(PyExc_TypeError,"Variable GREY_BRUSH is read-only.");
19869     return 1;
19870 }
19871
19872
19873 static PyObject *_wrap_GREY_BRUSH_get(void) {
19874     PyObject *pyobj;
19875
19876     pyobj = SWIG_NewPointerObj((void *)(wxGREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19877     return pyobj;
19878 }
19879
19880
19881 static int _wrap_MEDIUM_GREY_BRUSH_set(PyObject *) {
19882     PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_BRUSH is read-only.");
19883     return 1;
19884 }
19885
19886
19887 static PyObject *_wrap_MEDIUM_GREY_BRUSH_get(void) {
19888     PyObject *pyobj;
19889
19890     pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19891     return pyobj;
19892 }
19893
19894
19895 static int _wrap_LIGHT_GREY_BRUSH_set(PyObject *) {
19896     PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_BRUSH is read-only.");
19897     return 1;
19898 }
19899
19900
19901 static PyObject *_wrap_LIGHT_GREY_BRUSH_get(void) {
19902     PyObject *pyobj;
19903
19904     pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19905     return pyobj;
19906 }
19907
19908
19909 static int _wrap_BLACK_set(PyObject *) {
19910     PyErr_SetString(PyExc_TypeError,"Variable BLACK is read-only.");
19911     return 1;
19912 }
19913
19914
19915 static PyObject *_wrap_BLACK_get(void) {
19916     PyObject *pyobj;
19917
19918     pyobj = SWIG_NewPointerObj((void *)(wxBLACK), SWIGTYPE_p_wxColour, 0);
19919     return pyobj;
19920 }
19921
19922
19923 static int _wrap_WHITE_set(PyObject *) {
19924     PyErr_SetString(PyExc_TypeError,"Variable WHITE is read-only.");
19925     return 1;
19926 }
19927
19928
19929 static PyObject *_wrap_WHITE_get(void) {
19930     PyObject *pyobj;
19931
19932     pyobj = SWIG_NewPointerObj((void *)(wxWHITE), SWIGTYPE_p_wxColour, 0);
19933     return pyobj;
19934 }
19935
19936
19937 static int _wrap_RED_set(PyObject *) {
19938     PyErr_SetString(PyExc_TypeError,"Variable RED is read-only.");
19939     return 1;
19940 }
19941
19942
19943 static PyObject *_wrap_RED_get(void) {
19944     PyObject *pyobj;
19945
19946     pyobj = SWIG_NewPointerObj((void *)(wxRED), SWIGTYPE_p_wxColour, 0);
19947     return pyobj;
19948 }
19949
19950
19951 static int _wrap_BLUE_set(PyObject *) {
19952     PyErr_SetString(PyExc_TypeError,"Variable BLUE is read-only.");
19953     return 1;
19954 }
19955
19956
19957 static PyObject *_wrap_BLUE_get(void) {
19958     PyObject *pyobj;
19959
19960     pyobj = SWIG_NewPointerObj((void *)(wxBLUE), SWIGTYPE_p_wxColour, 0);
19961     return pyobj;
19962 }
19963
19964
19965 static int _wrap_GREEN_set(PyObject *) {
19966     PyErr_SetString(PyExc_TypeError,"Variable GREEN is read-only.");
19967     return 1;
19968 }
19969
19970
19971 static PyObject *_wrap_GREEN_get(void) {
19972     PyObject *pyobj;
19973
19974     pyobj = SWIG_NewPointerObj((void *)(wxGREEN), SWIGTYPE_p_wxColour, 0);
19975     return pyobj;
19976 }
19977
19978
19979 static int _wrap_CYAN_set(PyObject *) {
19980     PyErr_SetString(PyExc_TypeError,"Variable CYAN is read-only.");
19981     return 1;
19982 }
19983
19984
19985 static PyObject *_wrap_CYAN_get(void) {
19986     PyObject *pyobj;
19987
19988     pyobj = SWIG_NewPointerObj((void *)(wxCYAN), SWIGTYPE_p_wxColour, 0);
19989     return pyobj;
19990 }
19991
19992
19993 static int _wrap_LIGHT_GREY_set(PyObject *) {
19994     PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY is read-only.");
19995     return 1;
19996 }
19997
19998
19999 static PyObject *_wrap_LIGHT_GREY_get(void) {
20000     PyObject *pyobj;
20001
20002     pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY), SWIGTYPE_p_wxColour, 0);
20003     return pyobj;
20004 }
20005
20006
20007 static int _wrap_STANDARD_CURSOR_set(PyObject *) {
20008     PyErr_SetString(PyExc_TypeError,"Variable STANDARD_CURSOR is read-only.");
20009     return 1;
20010 }
20011
20012
20013 static PyObject *_wrap_STANDARD_CURSOR_get(void) {
20014     PyObject *pyobj;
20015
20016     pyobj = SWIG_NewPointerObj((void *)(wxSTANDARD_CURSOR), SWIGTYPE_p_wxCursor, 0);
20017     return pyobj;
20018 }
20019
20020
20021 static int _wrap_HOURGLASS_CURSOR_set(PyObject *) {
20022     PyErr_SetString(PyExc_TypeError,"Variable HOURGLASS_CURSOR is read-only.");
20023     return 1;
20024 }
20025
20026
20027 static PyObject *_wrap_HOURGLASS_CURSOR_get(void) {
20028     PyObject *pyobj;
20029
20030     pyobj = SWIG_NewPointerObj((void *)(wxHOURGLASS_CURSOR), SWIGTYPE_p_wxCursor, 0);
20031     return pyobj;
20032 }
20033
20034
20035 static int _wrap_CROSS_CURSOR_set(PyObject *) {
20036     PyErr_SetString(PyExc_TypeError,"Variable CROSS_CURSOR is read-only.");
20037     return 1;
20038 }
20039
20040
20041 static PyObject *_wrap_CROSS_CURSOR_get(void) {
20042     PyObject *pyobj;
20043
20044     pyobj = SWIG_NewPointerObj((void *)(wxCROSS_CURSOR), SWIGTYPE_p_wxCursor, 0);
20045     return pyobj;
20046 }
20047
20048
20049 static int _wrap_NullBitmap_set(PyObject *) {
20050     PyErr_SetString(PyExc_TypeError,"Variable NullBitmap is read-only.");
20051     return 1;
20052 }
20053
20054
20055 static PyObject *_wrap_NullBitmap_get(void) {
20056     PyObject *pyobj;
20057
20058     pyobj = SWIG_NewPointerObj((void *)(&wxNullBitmap), SWIGTYPE_p_wxBitmap, 0);
20059     return pyobj;
20060 }
20061
20062
20063 static int _wrap_NullIcon_set(PyObject *) {
20064     PyErr_SetString(PyExc_TypeError,"Variable NullIcon is read-only.");
20065     return 1;
20066 }
20067
20068
20069 static PyObject *_wrap_NullIcon_get(void) {
20070     PyObject *pyobj;
20071
20072     pyobj = SWIG_NewPointerObj((void *)(&wxNullIcon), SWIGTYPE_p_wxIcon, 0);
20073     return pyobj;
20074 }
20075
20076
20077 static int _wrap_NullCursor_set(PyObject *) {
20078     PyErr_SetString(PyExc_TypeError,"Variable NullCursor is read-only.");
20079     return 1;
20080 }
20081
20082
20083 static PyObject *_wrap_NullCursor_get(void) {
20084     PyObject *pyobj;
20085
20086     pyobj = SWIG_NewPointerObj((void *)(&wxNullCursor), SWIGTYPE_p_wxCursor, 0);
20087     return pyobj;
20088 }
20089
20090
20091 static int _wrap_NullPen_set(PyObject *) {
20092     PyErr_SetString(PyExc_TypeError,"Variable NullPen is read-only.");
20093     return 1;
20094 }
20095
20096
20097 static PyObject *_wrap_NullPen_get(void) {
20098     PyObject *pyobj;
20099
20100     pyobj = SWIG_NewPointerObj((void *)(&wxNullPen), SWIGTYPE_p_wxPen, 0);
20101     return pyobj;
20102 }
20103
20104
20105 static int _wrap_NullBrush_set(PyObject *) {
20106     PyErr_SetString(PyExc_TypeError,"Variable NullBrush is read-only.");
20107     return 1;
20108 }
20109
20110
20111 static PyObject *_wrap_NullBrush_get(void) {
20112     PyObject *pyobj;
20113
20114     pyobj = SWIG_NewPointerObj((void *)(&wxNullBrush), SWIGTYPE_p_wxBrush, 0);
20115     return pyobj;
20116 }
20117
20118
20119 static int _wrap_NullPalette_set(PyObject *) {
20120     PyErr_SetString(PyExc_TypeError,"Variable NullPalette is read-only.");
20121     return 1;
20122 }
20123
20124
20125 static PyObject *_wrap_NullPalette_get(void) {
20126     PyObject *pyobj;
20127
20128     pyobj = SWIG_NewPointerObj((void *)(&wxNullPalette), SWIGTYPE_p_wxPalette, 0);
20129     return pyobj;
20130 }
20131
20132
20133 static int _wrap_NullFont_set(PyObject *) {
20134     PyErr_SetString(PyExc_TypeError,"Variable NullFont is read-only.");
20135     return 1;
20136 }
20137
20138
20139 static PyObject *_wrap_NullFont_get(void) {
20140     PyObject *pyobj;
20141
20142     pyobj = SWIG_NewPointerObj((void *)(&wxNullFont), SWIGTYPE_p_wxFont, 0);
20143     return pyobj;
20144 }
20145
20146
20147 static int _wrap_NullColour_set(PyObject *) {
20148     PyErr_SetString(PyExc_TypeError,"Variable NullColour is read-only.");
20149     return 1;
20150 }
20151
20152
20153 static PyObject *_wrap_NullColour_get(void) {
20154     PyObject *pyobj;
20155
20156     pyobj = SWIG_NewPointerObj((void *)(&wxNullColour), SWIGTYPE_p_wxColour, 0);
20157     return pyobj;
20158 }
20159
20160
20161 static PyObject *_wrap_PenList_AddPen(PyObject *, PyObject *args, PyObject *kwargs) {
20162     PyObject *resultobj;
20163     wxPenList *arg1 = (wxPenList *) 0 ;
20164     wxPen *arg2 = (wxPen *) 0 ;
20165     PyObject * obj0 = 0 ;
20166     PyObject * obj1 = 0 ;
20167     char *kwnames[] = {
20168         (char *) "self",(char *) "pen", NULL
20169     };
20170
20171     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_AddPen",kwnames,&obj0,&obj1)) goto fail;
20172     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
20173     if (SWIG_arg_fail(1)) SWIG_fail;
20174     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
20175     if (SWIG_arg_fail(2)) SWIG_fail;
20176     {
20177         PyThreadState* __tstate = wxPyBeginAllowThreads();
20178         (arg1)->AddPen(arg2);
20179
20180         wxPyEndAllowThreads(__tstate);
20181         if (PyErr_Occurred()) SWIG_fail;
20182     }
20183     Py_INCREF(Py_None); resultobj = Py_None;
20184     return resultobj;
20185     fail:
20186     return NULL;
20187 }
20188
20189
20190 static PyObject *_wrap_PenList_FindOrCreatePen(PyObject *, PyObject *args, PyObject *kwargs) {
20191     PyObject *resultobj;
20192     wxPenList *arg1 = (wxPenList *) 0 ;
20193     wxColour *arg2 = 0 ;
20194     int arg3 ;
20195     int arg4 ;
20196     wxPen *result;
20197     wxColour temp2 ;
20198     PyObject * obj0 = 0 ;
20199     PyObject * obj1 = 0 ;
20200     PyObject * obj2 = 0 ;
20201     PyObject * obj3 = 0 ;
20202     char *kwnames[] = {
20203         (char *) "self",(char *) "colour",(char *) "width",(char *) "style", NULL
20204     };
20205
20206     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PenList_FindOrCreatePen",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20207     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
20208     if (SWIG_arg_fail(1)) SWIG_fail;
20209     {
20210         arg2 = &temp2;
20211         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20212     }
20213     {
20214         arg3 = (int)(SWIG_As_int(obj2));
20215         if (SWIG_arg_fail(3)) SWIG_fail;
20216     }
20217     {
20218         arg4 = (int)(SWIG_As_int(obj3));
20219         if (SWIG_arg_fail(4)) SWIG_fail;
20220     }
20221     {
20222         PyThreadState* __tstate = wxPyBeginAllowThreads();
20223         result = (wxPen *)(arg1)->FindOrCreatePen((wxColour const &)*arg2,arg3,arg4);
20224
20225         wxPyEndAllowThreads(__tstate);
20226         if (PyErr_Occurred()) SWIG_fail;
20227     }
20228     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 0);
20229     return resultobj;
20230     fail:
20231     return NULL;
20232 }
20233
20234
20235 static PyObject *_wrap_PenList_RemovePen(PyObject *, PyObject *args, PyObject *kwargs) {
20236     PyObject *resultobj;
20237     wxPenList *arg1 = (wxPenList *) 0 ;
20238     wxPen *arg2 = (wxPen *) 0 ;
20239     PyObject * obj0 = 0 ;
20240     PyObject * obj1 = 0 ;
20241     char *kwnames[] = {
20242         (char *) "self",(char *) "pen", NULL
20243     };
20244
20245     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_RemovePen",kwnames,&obj0,&obj1)) goto fail;
20246     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
20247     if (SWIG_arg_fail(1)) SWIG_fail;
20248     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
20249     if (SWIG_arg_fail(2)) SWIG_fail;
20250     {
20251         PyThreadState* __tstate = wxPyBeginAllowThreads();
20252         (arg1)->RemovePen(arg2);
20253
20254         wxPyEndAllowThreads(__tstate);
20255         if (PyErr_Occurred()) SWIG_fail;
20256     }
20257     Py_INCREF(Py_None); resultobj = Py_None;
20258     return resultobj;
20259     fail:
20260     return NULL;
20261 }
20262
20263
20264 static PyObject *_wrap_PenList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
20265     PyObject *resultobj;
20266     wxPenList *arg1 = (wxPenList *) 0 ;
20267     int result;
20268     PyObject * obj0 = 0 ;
20269     char *kwnames[] = {
20270         (char *) "self", NULL
20271     };
20272
20273     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PenList_GetCount",kwnames,&obj0)) goto fail;
20274     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
20275     if (SWIG_arg_fail(1)) SWIG_fail;
20276     {
20277         PyThreadState* __tstate = wxPyBeginAllowThreads();
20278         result = (int)(arg1)->GetCount();
20279
20280         wxPyEndAllowThreads(__tstate);
20281         if (PyErr_Occurred()) SWIG_fail;
20282     }
20283     {
20284         resultobj = SWIG_From_int((int)(result));
20285     }
20286     return resultobj;
20287     fail:
20288     return NULL;
20289 }
20290
20291
20292 static PyObject * PenList_swigregister(PyObject *, PyObject *args) {
20293     PyObject *obj;
20294     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20295     SWIG_TypeClientData(SWIGTYPE_p_wxPenList, obj);
20296     Py_INCREF(obj);
20297     return Py_BuildValue((char *)"");
20298 }
20299 static PyObject *_wrap_BrushList_AddBrush(PyObject *, PyObject *args, PyObject *kwargs) {
20300     PyObject *resultobj;
20301     wxBrushList *arg1 = (wxBrushList *) 0 ;
20302     wxBrush *arg2 = (wxBrush *) 0 ;
20303     PyObject * obj0 = 0 ;
20304     PyObject * obj1 = 0 ;
20305     char *kwnames[] = {
20306         (char *) "self",(char *) "brush", NULL
20307     };
20308
20309     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_AddBrush",kwnames,&obj0,&obj1)) goto fail;
20310     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
20311     if (SWIG_arg_fail(1)) SWIG_fail;
20312     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
20313     if (SWIG_arg_fail(2)) SWIG_fail;
20314     {
20315         PyThreadState* __tstate = wxPyBeginAllowThreads();
20316         (arg1)->AddBrush(arg2);
20317
20318         wxPyEndAllowThreads(__tstate);
20319         if (PyErr_Occurred()) SWIG_fail;
20320     }
20321     Py_INCREF(Py_None); resultobj = Py_None;
20322     return resultobj;
20323     fail:
20324     return NULL;
20325 }
20326
20327
20328 static PyObject *_wrap_BrushList_FindOrCreateBrush(PyObject *, PyObject *args, PyObject *kwargs) {
20329     PyObject *resultobj;
20330     wxBrushList *arg1 = (wxBrushList *) 0 ;
20331     wxColour *arg2 = 0 ;
20332     int arg3 ;
20333     wxBrush *result;
20334     wxColour temp2 ;
20335     PyObject * obj0 = 0 ;
20336     PyObject * obj1 = 0 ;
20337     PyObject * obj2 = 0 ;
20338     char *kwnames[] = {
20339         (char *) "self",(char *) "colour",(char *) "style", NULL
20340     };
20341
20342     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:BrushList_FindOrCreateBrush",kwnames,&obj0,&obj1,&obj2)) goto fail;
20343     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
20344     if (SWIG_arg_fail(1)) SWIG_fail;
20345     {
20346         arg2 = &temp2;
20347         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20348     }
20349     {
20350         arg3 = (int)(SWIG_As_int(obj2));
20351         if (SWIG_arg_fail(3)) SWIG_fail;
20352     }
20353     {
20354         PyThreadState* __tstate = wxPyBeginAllowThreads();
20355         result = (wxBrush *)(arg1)->FindOrCreateBrush((wxColour const &)*arg2,arg3);
20356
20357         wxPyEndAllowThreads(__tstate);
20358         if (PyErr_Occurred()) SWIG_fail;
20359     }
20360     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 0);
20361     return resultobj;
20362     fail:
20363     return NULL;
20364 }
20365
20366
20367 static PyObject *_wrap_BrushList_RemoveBrush(PyObject *, PyObject *args, PyObject *kwargs) {
20368     PyObject *resultobj;
20369     wxBrushList *arg1 = (wxBrushList *) 0 ;
20370     wxBrush *arg2 = (wxBrush *) 0 ;
20371     PyObject * obj0 = 0 ;
20372     PyObject * obj1 = 0 ;
20373     char *kwnames[] = {
20374         (char *) "self",(char *) "brush", NULL
20375     };
20376
20377     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_RemoveBrush",kwnames,&obj0,&obj1)) goto fail;
20378     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
20379     if (SWIG_arg_fail(1)) SWIG_fail;
20380     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
20381     if (SWIG_arg_fail(2)) SWIG_fail;
20382     {
20383         PyThreadState* __tstate = wxPyBeginAllowThreads();
20384         (arg1)->RemoveBrush(arg2);
20385
20386         wxPyEndAllowThreads(__tstate);
20387         if (PyErr_Occurred()) SWIG_fail;
20388     }
20389     Py_INCREF(Py_None); resultobj = Py_None;
20390     return resultobj;
20391     fail:
20392     return NULL;
20393 }
20394
20395
20396 static PyObject *_wrap_BrushList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
20397     PyObject *resultobj;
20398     wxBrushList *arg1 = (wxBrushList *) 0 ;
20399     int result;
20400     PyObject * obj0 = 0 ;
20401     char *kwnames[] = {
20402         (char *) "self", NULL
20403     };
20404
20405     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BrushList_GetCount",kwnames,&obj0)) goto fail;
20406     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
20407     if (SWIG_arg_fail(1)) SWIG_fail;
20408     {
20409         PyThreadState* __tstate = wxPyBeginAllowThreads();
20410         result = (int)(arg1)->GetCount();
20411
20412         wxPyEndAllowThreads(__tstate);
20413         if (PyErr_Occurred()) SWIG_fail;
20414     }
20415     {
20416         resultobj = SWIG_From_int((int)(result));
20417     }
20418     return resultobj;
20419     fail:
20420     return NULL;
20421 }
20422
20423
20424 static PyObject * BrushList_swigregister(PyObject *, PyObject *args) {
20425     PyObject *obj;
20426     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20427     SWIG_TypeClientData(SWIGTYPE_p_wxBrushList, obj);
20428     Py_INCREF(obj);
20429     return Py_BuildValue((char *)"");
20430 }
20431 static PyObject *_wrap_new_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
20432     PyObject *resultobj;
20433     wxColourDatabase *result;
20434     char *kwnames[] = {
20435         NULL
20436     };
20437
20438     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ColourDatabase",kwnames)) goto fail;
20439     {
20440         if (!wxPyCheckForApp()) SWIG_fail;
20441         PyThreadState* __tstate = wxPyBeginAllowThreads();
20442         result = (wxColourDatabase *)new wxColourDatabase();
20443
20444         wxPyEndAllowThreads(__tstate);
20445         if (PyErr_Occurred()) SWIG_fail;
20446     }
20447     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourDatabase, 1);
20448     return resultobj;
20449     fail:
20450     return NULL;
20451 }
20452
20453
20454 static PyObject *_wrap_delete_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
20455     PyObject *resultobj;
20456     wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20457     PyObject * obj0 = 0 ;
20458     char *kwnames[] = {
20459         (char *) "self", NULL
20460     };
20461
20462     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ColourDatabase",kwnames,&obj0)) goto fail;
20463     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20464     if (SWIG_arg_fail(1)) SWIG_fail;
20465     {
20466         PyThreadState* __tstate = wxPyBeginAllowThreads();
20467         delete arg1;
20468
20469         wxPyEndAllowThreads(__tstate);
20470         if (PyErr_Occurred()) SWIG_fail;
20471     }
20472     Py_INCREF(Py_None); resultobj = Py_None;
20473     return resultobj;
20474     fail:
20475     return NULL;
20476 }
20477
20478
20479 static PyObject *_wrap_ColourDatabase_Find(PyObject *, PyObject *args, PyObject *kwargs) {
20480     PyObject *resultobj;
20481     wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20482     wxString *arg2 = 0 ;
20483     wxColour result;
20484     bool temp2 = false ;
20485     PyObject * obj0 = 0 ;
20486     PyObject * obj1 = 0 ;
20487     char *kwnames[] = {
20488         (char *) "self",(char *) "name", NULL
20489     };
20490
20491     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_Find",kwnames,&obj0,&obj1)) goto fail;
20492     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20493     if (SWIG_arg_fail(1)) SWIG_fail;
20494     {
20495         arg2 = wxString_in_helper(obj1);
20496         if (arg2 == NULL) SWIG_fail;
20497         temp2 = true;
20498     }
20499     {
20500         PyThreadState* __tstate = wxPyBeginAllowThreads();
20501         result = ((wxColourDatabase const *)arg1)->Find((wxString const &)*arg2);
20502
20503         wxPyEndAllowThreads(__tstate);
20504         if (PyErr_Occurred()) SWIG_fail;
20505     }
20506     {
20507         wxColour * resultptr;
20508         resultptr = new wxColour((wxColour &)(result));
20509         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20510     }
20511     {
20512         if (temp2)
20513         delete arg2;
20514     }
20515     return resultobj;
20516     fail:
20517     {
20518         if (temp2)
20519         delete arg2;
20520     }
20521     return NULL;
20522 }
20523
20524
20525 static PyObject *_wrap_ColourDatabase_FindName(PyObject *, PyObject *args, PyObject *kwargs) {
20526     PyObject *resultobj;
20527     wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20528     wxColour *arg2 = 0 ;
20529     wxString result;
20530     wxColour temp2 ;
20531     PyObject * obj0 = 0 ;
20532     PyObject * obj1 = 0 ;
20533     char *kwnames[] = {
20534         (char *) "self",(char *) "colour", NULL
20535     };
20536
20537     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_FindName",kwnames,&obj0,&obj1)) goto fail;
20538     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20539     if (SWIG_arg_fail(1)) SWIG_fail;
20540     {
20541         arg2 = &temp2;
20542         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20543     }
20544     {
20545         PyThreadState* __tstate = wxPyBeginAllowThreads();
20546         result = ((wxColourDatabase const *)arg1)->FindName((wxColour const &)*arg2);
20547
20548         wxPyEndAllowThreads(__tstate);
20549         if (PyErr_Occurred()) SWIG_fail;
20550     }
20551     {
20552 #if wxUSE_UNICODE
20553         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20554 #else
20555         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20556 #endif
20557     }
20558     return resultobj;
20559     fail:
20560     return NULL;
20561 }
20562
20563
20564 static PyObject *_wrap_ColourDatabase_AddColour(PyObject *, PyObject *args, PyObject *kwargs) {
20565     PyObject *resultobj;
20566     wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20567     wxString *arg2 = 0 ;
20568     wxColour *arg3 = 0 ;
20569     bool temp2 = false ;
20570     wxColour temp3 ;
20571     PyObject * obj0 = 0 ;
20572     PyObject * obj1 = 0 ;
20573     PyObject * obj2 = 0 ;
20574     char *kwnames[] = {
20575         (char *) "self",(char *) "name",(char *) "colour", NULL
20576     };
20577
20578     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ColourDatabase_AddColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
20579     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20580     if (SWIG_arg_fail(1)) SWIG_fail;
20581     {
20582         arg2 = wxString_in_helper(obj1);
20583         if (arg2 == NULL) SWIG_fail;
20584         temp2 = true;
20585     }
20586     {
20587         arg3 = &temp3;
20588         if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
20589     }
20590     {
20591         PyThreadState* __tstate = wxPyBeginAllowThreads();
20592         (arg1)->AddColour((wxString const &)*arg2,(wxColour const &)*arg3);
20593
20594         wxPyEndAllowThreads(__tstate);
20595         if (PyErr_Occurred()) SWIG_fail;
20596     }
20597     Py_INCREF(Py_None); resultobj = Py_None;
20598     {
20599         if (temp2)
20600         delete arg2;
20601     }
20602     return resultobj;
20603     fail:
20604     {
20605         if (temp2)
20606         delete arg2;
20607     }
20608     return NULL;
20609 }
20610
20611
20612 static PyObject *_wrap_ColourDatabase_Append(PyObject *, PyObject *args, PyObject *kwargs) {
20613     PyObject *resultobj;
20614     wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20615     wxString *arg2 = 0 ;
20616     int arg3 ;
20617     int arg4 ;
20618     int arg5 ;
20619     bool temp2 = false ;
20620     PyObject * obj0 = 0 ;
20621     PyObject * obj1 = 0 ;
20622     PyObject * obj2 = 0 ;
20623     PyObject * obj3 = 0 ;
20624     PyObject * obj4 = 0 ;
20625     char *kwnames[] = {
20626         (char *) "self",(char *) "name",(char *) "red",(char *) "green",(char *) "blue", NULL
20627     };
20628
20629     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:ColourDatabase_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20630     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20631     if (SWIG_arg_fail(1)) SWIG_fail;
20632     {
20633         arg2 = wxString_in_helper(obj1);
20634         if (arg2 == NULL) SWIG_fail;
20635         temp2 = true;
20636     }
20637     {
20638         arg3 = (int)(SWIG_As_int(obj2));
20639         if (SWIG_arg_fail(3)) SWIG_fail;
20640     }
20641     {
20642         arg4 = (int)(SWIG_As_int(obj3));
20643         if (SWIG_arg_fail(4)) SWIG_fail;
20644     }
20645     {
20646         arg5 = (int)(SWIG_As_int(obj4));
20647         if (SWIG_arg_fail(5)) SWIG_fail;
20648     }
20649     {
20650         PyThreadState* __tstate = wxPyBeginAllowThreads();
20651         wxColourDatabase_Append(arg1,(wxString const &)*arg2,arg3,arg4,arg5);
20652
20653         wxPyEndAllowThreads(__tstate);
20654         if (PyErr_Occurred()) SWIG_fail;
20655     }
20656     Py_INCREF(Py_None); resultobj = Py_None;
20657     {
20658         if (temp2)
20659         delete arg2;
20660     }
20661     return resultobj;
20662     fail:
20663     {
20664         if (temp2)
20665         delete arg2;
20666     }
20667     return NULL;
20668 }
20669
20670
20671 static PyObject * ColourDatabase_swigregister(PyObject *, PyObject *args) {
20672     PyObject *obj;
20673     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20674     SWIG_TypeClientData(SWIGTYPE_p_wxColourDatabase, obj);
20675     Py_INCREF(obj);
20676     return Py_BuildValue((char *)"");
20677 }
20678 static PyObject *_wrap_FontList_AddFont(PyObject *, PyObject *args, PyObject *kwargs) {
20679     PyObject *resultobj;
20680     wxFontList *arg1 = (wxFontList *) 0 ;
20681     wxFont *arg2 = (wxFont *) 0 ;
20682     PyObject * obj0 = 0 ;
20683     PyObject * obj1 = 0 ;
20684     char *kwnames[] = {
20685         (char *) "self",(char *) "font", NULL
20686     };
20687
20688     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_AddFont",kwnames,&obj0,&obj1)) goto fail;
20689     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20690     if (SWIG_arg_fail(1)) SWIG_fail;
20691     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
20692     if (SWIG_arg_fail(2)) SWIG_fail;
20693     {
20694         PyThreadState* __tstate = wxPyBeginAllowThreads();
20695         (arg1)->AddFont(arg2);
20696
20697         wxPyEndAllowThreads(__tstate);
20698         if (PyErr_Occurred()) SWIG_fail;
20699     }
20700     Py_INCREF(Py_None); resultobj = Py_None;
20701     return resultobj;
20702     fail:
20703     return NULL;
20704 }
20705
20706
20707 static PyObject *_wrap_FontList_FindOrCreateFont(PyObject *, PyObject *args, PyObject *kwargs) {
20708     PyObject *resultobj;
20709     wxFontList *arg1 = (wxFontList *) 0 ;
20710     int arg2 ;
20711     int arg3 ;
20712     int arg4 ;
20713     int arg5 ;
20714     bool arg6 = (bool) false ;
20715     wxString const &arg7_defvalue = wxPyEmptyString ;
20716     wxString *arg7 = (wxString *) &arg7_defvalue ;
20717     wxFontEncoding arg8 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
20718     wxFont *result;
20719     bool temp7 = false ;
20720     PyObject * obj0 = 0 ;
20721     PyObject * obj1 = 0 ;
20722     PyObject * obj2 = 0 ;
20723     PyObject * obj3 = 0 ;
20724     PyObject * obj4 = 0 ;
20725     PyObject * obj5 = 0 ;
20726     PyObject * obj6 = 0 ;
20727     PyObject * obj7 = 0 ;
20728     char *kwnames[] = {
20729         (char *) "self",(char *) "point_size",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "facename",(char *) "encoding", NULL
20730     };
20731
20732     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:FontList_FindOrCreateFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20733     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20734     if (SWIG_arg_fail(1)) SWIG_fail;
20735     {
20736         arg2 = (int)(SWIG_As_int(obj1));
20737         if (SWIG_arg_fail(2)) SWIG_fail;
20738     }
20739     {
20740         arg3 = (int)(SWIG_As_int(obj2));
20741         if (SWIG_arg_fail(3)) SWIG_fail;
20742     }
20743     {
20744         arg4 = (int)(SWIG_As_int(obj3));
20745         if (SWIG_arg_fail(4)) SWIG_fail;
20746     }
20747     {
20748         arg5 = (int)(SWIG_As_int(obj4));
20749         if (SWIG_arg_fail(5)) SWIG_fail;
20750     }
20751     if (obj5) {
20752         {
20753             arg6 = (bool)(SWIG_As_bool(obj5));
20754             if (SWIG_arg_fail(6)) SWIG_fail;
20755         }
20756     }
20757     if (obj6) {
20758         {
20759             arg7 = wxString_in_helper(obj6);
20760             if (arg7 == NULL) SWIG_fail;
20761             temp7 = true;
20762         }
20763     }
20764     if (obj7) {
20765         {
20766             arg8 = (wxFontEncoding)(SWIG_As_int(obj7));
20767             if (SWIG_arg_fail(8)) SWIG_fail;
20768         }
20769     }
20770     {
20771         PyThreadState* __tstate = wxPyBeginAllowThreads();
20772         result = (wxFont *)(arg1)->FindOrCreateFont(arg2,arg3,arg4,arg5,arg6,(wxString const &)*arg7,(wxFontEncoding )arg8);
20773
20774         wxPyEndAllowThreads(__tstate);
20775         if (PyErr_Occurred()) SWIG_fail;
20776     }
20777     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
20778     {
20779         if (temp7)
20780         delete arg7;
20781     }
20782     return resultobj;
20783     fail:
20784     {
20785         if (temp7)
20786         delete arg7;
20787     }
20788     return NULL;
20789 }
20790
20791
20792 static PyObject *_wrap_FontList_RemoveFont(PyObject *, PyObject *args, PyObject *kwargs) {
20793     PyObject *resultobj;
20794     wxFontList *arg1 = (wxFontList *) 0 ;
20795     wxFont *arg2 = (wxFont *) 0 ;
20796     PyObject * obj0 = 0 ;
20797     PyObject * obj1 = 0 ;
20798     char *kwnames[] = {
20799         (char *) "self",(char *) "font", NULL
20800     };
20801
20802     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_RemoveFont",kwnames,&obj0,&obj1)) goto fail;
20803     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20804     if (SWIG_arg_fail(1)) SWIG_fail;
20805     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
20806     if (SWIG_arg_fail(2)) SWIG_fail;
20807     {
20808         PyThreadState* __tstate = wxPyBeginAllowThreads();
20809         (arg1)->RemoveFont(arg2);
20810
20811         wxPyEndAllowThreads(__tstate);
20812         if (PyErr_Occurred()) SWIG_fail;
20813     }
20814     Py_INCREF(Py_None); resultobj = Py_None;
20815     return resultobj;
20816     fail:
20817     return NULL;
20818 }
20819
20820
20821 static PyObject *_wrap_FontList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
20822     PyObject *resultobj;
20823     wxFontList *arg1 = (wxFontList *) 0 ;
20824     int result;
20825     PyObject * obj0 = 0 ;
20826     char *kwnames[] = {
20827         (char *) "self", NULL
20828     };
20829
20830     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontList_GetCount",kwnames,&obj0)) goto fail;
20831     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20832     if (SWIG_arg_fail(1)) SWIG_fail;
20833     {
20834         PyThreadState* __tstate = wxPyBeginAllowThreads();
20835         result = (int)(arg1)->GetCount();
20836
20837         wxPyEndAllowThreads(__tstate);
20838         if (PyErr_Occurred()) SWIG_fail;
20839     }
20840     {
20841         resultobj = SWIG_From_int((int)(result));
20842     }
20843     return resultobj;
20844     fail:
20845     return NULL;
20846 }
20847
20848
20849 static PyObject * FontList_swigregister(PyObject *, PyObject *args) {
20850     PyObject *obj;
20851     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20852     SWIG_TypeClientData(SWIGTYPE_p_wxFontList, obj);
20853     Py_INCREF(obj);
20854     return Py_BuildValue((char *)"");
20855 }
20856 static int _wrap_TheFontList_set(PyObject *) {
20857     PyErr_SetString(PyExc_TypeError,"Variable TheFontList is read-only.");
20858     return 1;
20859 }
20860
20861
20862 static PyObject *_wrap_TheFontList_get(void) {
20863     PyObject *pyobj;
20864
20865     pyobj = SWIG_NewPointerObj((void *)(wxTheFontList), SWIGTYPE_p_wxFontList, 0);
20866     return pyobj;
20867 }
20868
20869
20870 static int _wrap_ThePenList_set(PyObject *) {
20871     PyErr_SetString(PyExc_TypeError,"Variable ThePenList is read-only.");
20872     return 1;
20873 }
20874
20875
20876 static PyObject *_wrap_ThePenList_get(void) {
20877     PyObject *pyobj;
20878
20879     pyobj = SWIG_NewPointerObj((void *)(wxThePenList), SWIGTYPE_p_wxPenList, 0);
20880     return pyobj;
20881 }
20882
20883
20884 static int _wrap_TheBrushList_set(PyObject *) {
20885     PyErr_SetString(PyExc_TypeError,"Variable TheBrushList is read-only.");
20886     return 1;
20887 }
20888
20889
20890 static PyObject *_wrap_TheBrushList_get(void) {
20891     PyObject *pyobj;
20892
20893     pyobj = SWIG_NewPointerObj((void *)(wxTheBrushList), SWIGTYPE_p_wxBrushList, 0);
20894     return pyobj;
20895 }
20896
20897
20898 static int _wrap_TheColourDatabase_set(PyObject *) {
20899     PyErr_SetString(PyExc_TypeError,"Variable TheColourDatabase is read-only.");
20900     return 1;
20901 }
20902
20903
20904 static PyObject *_wrap_TheColourDatabase_get(void) {
20905     PyObject *pyobj;
20906
20907     pyobj = SWIG_NewPointerObj((void *)(wxTheColourDatabase), SWIGTYPE_p_wxColourDatabase, 0);
20908     return pyobj;
20909 }
20910
20911
20912 static PyObject *_wrap_new_Effects(PyObject *, PyObject *args, PyObject *kwargs) {
20913     PyObject *resultobj;
20914     wxEffects *result;
20915     char *kwnames[] = {
20916         NULL
20917     };
20918
20919     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Effects",kwnames)) goto fail;
20920     {
20921         PyThreadState* __tstate = wxPyBeginAllowThreads();
20922         result = (wxEffects *)new wxEffects();
20923
20924         wxPyEndAllowThreads(__tstate);
20925         if (PyErr_Occurred()) SWIG_fail;
20926     }
20927     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEffects, 1);
20928     return resultobj;
20929     fail:
20930     return NULL;
20931 }
20932
20933
20934 static PyObject *_wrap_Effects_GetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
20935     PyObject *resultobj;
20936     wxEffects *arg1 = (wxEffects *) 0 ;
20937     wxColour result;
20938     PyObject * obj0 = 0 ;
20939     char *kwnames[] = {
20940         (char *) "self", NULL
20941     };
20942
20943     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetHighlightColour",kwnames,&obj0)) goto fail;
20944     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20945     if (SWIG_arg_fail(1)) SWIG_fail;
20946     {
20947         PyThreadState* __tstate = wxPyBeginAllowThreads();
20948         result = ((wxEffects const *)arg1)->GetHighlightColour();
20949
20950         wxPyEndAllowThreads(__tstate);
20951         if (PyErr_Occurred()) SWIG_fail;
20952     }
20953     {
20954         wxColour * resultptr;
20955         resultptr = new wxColour((wxColour &)(result));
20956         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20957     }
20958     return resultobj;
20959     fail:
20960     return NULL;
20961 }
20962
20963
20964 static PyObject *_wrap_Effects_GetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20965     PyObject *resultobj;
20966     wxEffects *arg1 = (wxEffects *) 0 ;
20967     wxColour result;
20968     PyObject * obj0 = 0 ;
20969     char *kwnames[] = {
20970         (char *) "self", NULL
20971     };
20972
20973     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetLightShadow",kwnames,&obj0)) goto fail;
20974     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20975     if (SWIG_arg_fail(1)) SWIG_fail;
20976     {
20977         PyThreadState* __tstate = wxPyBeginAllowThreads();
20978         result = ((wxEffects const *)arg1)->GetLightShadow();
20979
20980         wxPyEndAllowThreads(__tstate);
20981         if (PyErr_Occurred()) SWIG_fail;
20982     }
20983     {
20984         wxColour * resultptr;
20985         resultptr = new wxColour((wxColour &)(result));
20986         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20987     }
20988     return resultobj;
20989     fail:
20990     return NULL;
20991 }
20992
20993
20994 static PyObject *_wrap_Effects_GetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
20995     PyObject *resultobj;
20996     wxEffects *arg1 = (wxEffects *) 0 ;
20997     wxColour result;
20998     PyObject * obj0 = 0 ;
20999     char *kwnames[] = {
21000         (char *) "self", NULL
21001     };
21002
21003     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetFaceColour",kwnames,&obj0)) goto fail;
21004     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21005     if (SWIG_arg_fail(1)) SWIG_fail;
21006     {
21007         PyThreadState* __tstate = wxPyBeginAllowThreads();
21008         result = ((wxEffects const *)arg1)->GetFaceColour();
21009
21010         wxPyEndAllowThreads(__tstate);
21011         if (PyErr_Occurred()) SWIG_fail;
21012     }
21013     {
21014         wxColour * resultptr;
21015         resultptr = new wxColour((wxColour &)(result));
21016         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
21017     }
21018     return resultobj;
21019     fail:
21020     return NULL;
21021 }
21022
21023
21024 static PyObject *_wrap_Effects_GetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21025     PyObject *resultobj;
21026     wxEffects *arg1 = (wxEffects *) 0 ;
21027     wxColour result;
21028     PyObject * obj0 = 0 ;
21029     char *kwnames[] = {
21030         (char *) "self", NULL
21031     };
21032
21033     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetMediumShadow",kwnames,&obj0)) goto fail;
21034     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21035     if (SWIG_arg_fail(1)) SWIG_fail;
21036     {
21037         PyThreadState* __tstate = wxPyBeginAllowThreads();
21038         result = ((wxEffects const *)arg1)->GetMediumShadow();
21039
21040         wxPyEndAllowThreads(__tstate);
21041         if (PyErr_Occurred()) SWIG_fail;
21042     }
21043     {
21044         wxColour * resultptr;
21045         resultptr = new wxColour((wxColour &)(result));
21046         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
21047     }
21048     return resultobj;
21049     fail:
21050     return NULL;
21051 }
21052
21053
21054 static PyObject *_wrap_Effects_GetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21055     PyObject *resultobj;
21056     wxEffects *arg1 = (wxEffects *) 0 ;
21057     wxColour result;
21058     PyObject * obj0 = 0 ;
21059     char *kwnames[] = {
21060         (char *) "self", NULL
21061     };
21062
21063     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetDarkShadow",kwnames,&obj0)) goto fail;
21064     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21065     if (SWIG_arg_fail(1)) SWIG_fail;
21066     {
21067         PyThreadState* __tstate = wxPyBeginAllowThreads();
21068         result = ((wxEffects const *)arg1)->GetDarkShadow();
21069
21070         wxPyEndAllowThreads(__tstate);
21071         if (PyErr_Occurred()) SWIG_fail;
21072     }
21073     {
21074         wxColour * resultptr;
21075         resultptr = new wxColour((wxColour &)(result));
21076         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
21077     }
21078     return resultobj;
21079     fail:
21080     return NULL;
21081 }
21082
21083
21084 static PyObject *_wrap_Effects_SetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
21085     PyObject *resultobj;
21086     wxEffects *arg1 = (wxEffects *) 0 ;
21087     wxColour *arg2 = 0 ;
21088     wxColour temp2 ;
21089     PyObject * obj0 = 0 ;
21090     PyObject * obj1 = 0 ;
21091     char *kwnames[] = {
21092         (char *) "self",(char *) "c", NULL
21093     };
21094
21095     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetHighlightColour",kwnames,&obj0,&obj1)) goto fail;
21096     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21097     if (SWIG_arg_fail(1)) SWIG_fail;
21098     {
21099         arg2 = &temp2;
21100         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21101     }
21102     {
21103         PyThreadState* __tstate = wxPyBeginAllowThreads();
21104         (arg1)->SetHighlightColour((wxColour const &)*arg2);
21105
21106         wxPyEndAllowThreads(__tstate);
21107         if (PyErr_Occurred()) SWIG_fail;
21108     }
21109     Py_INCREF(Py_None); resultobj = Py_None;
21110     return resultobj;
21111     fail:
21112     return NULL;
21113 }
21114
21115
21116 static PyObject *_wrap_Effects_SetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21117     PyObject *resultobj;
21118     wxEffects *arg1 = (wxEffects *) 0 ;
21119     wxColour *arg2 = 0 ;
21120     wxColour temp2 ;
21121     PyObject * obj0 = 0 ;
21122     PyObject * obj1 = 0 ;
21123     char *kwnames[] = {
21124         (char *) "self",(char *) "c", NULL
21125     };
21126
21127     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetLightShadow",kwnames,&obj0,&obj1)) goto fail;
21128     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21129     if (SWIG_arg_fail(1)) SWIG_fail;
21130     {
21131         arg2 = &temp2;
21132         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21133     }
21134     {
21135         PyThreadState* __tstate = wxPyBeginAllowThreads();
21136         (arg1)->SetLightShadow((wxColour const &)*arg2);
21137
21138         wxPyEndAllowThreads(__tstate);
21139         if (PyErr_Occurred()) SWIG_fail;
21140     }
21141     Py_INCREF(Py_None); resultobj = Py_None;
21142     return resultobj;
21143     fail:
21144     return NULL;
21145 }
21146
21147
21148 static PyObject *_wrap_Effects_SetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
21149     PyObject *resultobj;
21150     wxEffects *arg1 = (wxEffects *) 0 ;
21151     wxColour *arg2 = 0 ;
21152     wxColour temp2 ;
21153     PyObject * obj0 = 0 ;
21154     PyObject * obj1 = 0 ;
21155     char *kwnames[] = {
21156         (char *) "self",(char *) "c", NULL
21157     };
21158
21159     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetFaceColour",kwnames,&obj0,&obj1)) goto fail;
21160     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21161     if (SWIG_arg_fail(1)) SWIG_fail;
21162     {
21163         arg2 = &temp2;
21164         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21165     }
21166     {
21167         PyThreadState* __tstate = wxPyBeginAllowThreads();
21168         (arg1)->SetFaceColour((wxColour const &)*arg2);
21169
21170         wxPyEndAllowThreads(__tstate);
21171         if (PyErr_Occurred()) SWIG_fail;
21172     }
21173     Py_INCREF(Py_None); resultobj = Py_None;
21174     return resultobj;
21175     fail:
21176     return NULL;
21177 }
21178
21179
21180 static PyObject *_wrap_Effects_SetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21181     PyObject *resultobj;
21182     wxEffects *arg1 = (wxEffects *) 0 ;
21183     wxColour *arg2 = 0 ;
21184     wxColour temp2 ;
21185     PyObject * obj0 = 0 ;
21186     PyObject * obj1 = 0 ;
21187     char *kwnames[] = {
21188         (char *) "self",(char *) "c", NULL
21189     };
21190
21191     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetMediumShadow",kwnames,&obj0,&obj1)) goto fail;
21192     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21193     if (SWIG_arg_fail(1)) SWIG_fail;
21194     {
21195         arg2 = &temp2;
21196         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21197     }
21198     {
21199         PyThreadState* __tstate = wxPyBeginAllowThreads();
21200         (arg1)->SetMediumShadow((wxColour const &)*arg2);
21201
21202         wxPyEndAllowThreads(__tstate);
21203         if (PyErr_Occurred()) SWIG_fail;
21204     }
21205     Py_INCREF(Py_None); resultobj = Py_None;
21206     return resultobj;
21207     fail:
21208     return NULL;
21209 }
21210
21211
21212 static PyObject *_wrap_Effects_SetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21213     PyObject *resultobj;
21214     wxEffects *arg1 = (wxEffects *) 0 ;
21215     wxColour *arg2 = 0 ;
21216     wxColour temp2 ;
21217     PyObject * obj0 = 0 ;
21218     PyObject * obj1 = 0 ;
21219     char *kwnames[] = {
21220         (char *) "self",(char *) "c", NULL
21221     };
21222
21223     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetDarkShadow",kwnames,&obj0,&obj1)) goto fail;
21224     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21225     if (SWIG_arg_fail(1)) SWIG_fail;
21226     {
21227         arg2 = &temp2;
21228         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21229     }
21230     {
21231         PyThreadState* __tstate = wxPyBeginAllowThreads();
21232         (arg1)->SetDarkShadow((wxColour const &)*arg2);
21233
21234         wxPyEndAllowThreads(__tstate);
21235         if (PyErr_Occurred()) SWIG_fail;
21236     }
21237     Py_INCREF(Py_None); resultobj = Py_None;
21238     return resultobj;
21239     fail:
21240     return NULL;
21241 }
21242
21243
21244 static PyObject *_wrap_Effects_Set(PyObject *, PyObject *args, PyObject *kwargs) {
21245     PyObject *resultobj;
21246     wxEffects *arg1 = (wxEffects *) 0 ;
21247     wxColour *arg2 = 0 ;
21248     wxColour *arg3 = 0 ;
21249     wxColour *arg4 = 0 ;
21250     wxColour *arg5 = 0 ;
21251     wxColour *arg6 = 0 ;
21252     wxColour temp2 ;
21253     wxColour temp3 ;
21254     wxColour temp4 ;
21255     wxColour temp5 ;
21256     wxColour temp6 ;
21257     PyObject * obj0 = 0 ;
21258     PyObject * obj1 = 0 ;
21259     PyObject * obj2 = 0 ;
21260     PyObject * obj3 = 0 ;
21261     PyObject * obj4 = 0 ;
21262     PyObject * obj5 = 0 ;
21263     char *kwnames[] = {
21264         (char *) "self",(char *) "highlightColour",(char *) "lightShadow",(char *) "faceColour",(char *) "mediumShadow",(char *) "darkShadow", NULL
21265     };
21266
21267     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Effects_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
21268     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21269     if (SWIG_arg_fail(1)) SWIG_fail;
21270     {
21271         arg2 = &temp2;
21272         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21273     }
21274     {
21275         arg3 = &temp3;
21276         if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
21277     }
21278     {
21279         arg4 = &temp4;
21280         if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
21281     }
21282     {
21283         arg5 = &temp5;
21284         if ( ! wxColour_helper(obj4, &arg5)) SWIG_fail;
21285     }
21286     {
21287         arg6 = &temp6;
21288         if ( ! wxColour_helper(obj5, &arg6)) SWIG_fail;
21289     }
21290     {
21291         PyThreadState* __tstate = wxPyBeginAllowThreads();
21292         (arg1)->Set((wxColour const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,(wxColour const &)*arg5,(wxColour const &)*arg6);
21293
21294         wxPyEndAllowThreads(__tstate);
21295         if (PyErr_Occurred()) SWIG_fail;
21296     }
21297     Py_INCREF(Py_None); resultobj = Py_None;
21298     return resultobj;
21299     fail:
21300     return NULL;
21301 }
21302
21303
21304 static PyObject *_wrap_Effects_DrawSunkenEdge(PyObject *, PyObject *args, PyObject *kwargs) {
21305     PyObject *resultobj;
21306     wxEffects *arg1 = (wxEffects *) 0 ;
21307     wxDC *arg2 = 0 ;
21308     wxRect *arg3 = 0 ;
21309     int arg4 = (int) 1 ;
21310     wxRect temp3 ;
21311     PyObject * obj0 = 0 ;
21312     PyObject * obj1 = 0 ;
21313     PyObject * obj2 = 0 ;
21314     PyObject * obj3 = 0 ;
21315     char *kwnames[] = {
21316         (char *) "self",(char *) "dc",(char *) "rect",(char *) "borderSize", NULL
21317     };
21318
21319     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Effects_DrawSunkenEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21320     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21321     if (SWIG_arg_fail(1)) SWIG_fail;
21322     {
21323         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21324         if (SWIG_arg_fail(2)) SWIG_fail;
21325         if (arg2 == NULL) {
21326             SWIG_null_ref("wxDC");
21327         }
21328         if (SWIG_arg_fail(2)) SWIG_fail;
21329     }
21330     {
21331         arg3 = &temp3;
21332         if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
21333     }
21334     if (obj3) {
21335         {
21336             arg4 = (int)(SWIG_As_int(obj3));
21337             if (SWIG_arg_fail(4)) SWIG_fail;
21338         }
21339     }
21340     {
21341         PyThreadState* __tstate = wxPyBeginAllowThreads();
21342         (arg1)->DrawSunkenEdge(*arg2,(wxRect const &)*arg3,arg4);
21343
21344         wxPyEndAllowThreads(__tstate);
21345         if (PyErr_Occurred()) SWIG_fail;
21346     }
21347     Py_INCREF(Py_None); resultobj = Py_None;
21348     return resultobj;
21349     fail:
21350     return NULL;
21351 }
21352
21353
21354 static PyObject *_wrap_Effects_TileBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
21355     PyObject *resultobj;
21356     wxEffects *arg1 = (wxEffects *) 0 ;
21357     wxRect *arg2 = 0 ;
21358     wxDC *arg3 = 0 ;
21359     wxBitmap *arg4 = 0 ;
21360     bool result;
21361     wxRect temp2 ;
21362     PyObject * obj0 = 0 ;
21363     PyObject * obj1 = 0 ;
21364     PyObject * obj2 = 0 ;
21365     PyObject * obj3 = 0 ;
21366     char *kwnames[] = {
21367         (char *) "self",(char *) "rect",(char *) "dc",(char *) "bitmap", NULL
21368     };
21369
21370     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Effects_TileBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21371     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21372     if (SWIG_arg_fail(1)) SWIG_fail;
21373     {
21374         arg2 = &temp2;
21375         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
21376     }
21377     {
21378         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21379         if (SWIG_arg_fail(3)) SWIG_fail;
21380         if (arg3 == NULL) {
21381             SWIG_null_ref("wxDC");
21382         }
21383         if (SWIG_arg_fail(3)) SWIG_fail;
21384     }
21385     {
21386         SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
21387         if (SWIG_arg_fail(4)) SWIG_fail;
21388         if (arg4 == NULL) {
21389             SWIG_null_ref("wxBitmap");
21390         }
21391         if (SWIG_arg_fail(4)) SWIG_fail;
21392     }
21393     {
21394         PyThreadState* __tstate = wxPyBeginAllowThreads();
21395         result = (bool)(arg1)->TileBitmap((wxRect const &)*arg2,*arg3,*arg4);
21396
21397         wxPyEndAllowThreads(__tstate);
21398         if (PyErr_Occurred()) SWIG_fail;
21399     }
21400     {
21401         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21402     }
21403     return resultobj;
21404     fail:
21405     return NULL;
21406 }
21407
21408
21409 static PyObject * Effects_swigregister(PyObject *, PyObject *args) {
21410     PyObject *obj;
21411     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21412     SWIG_TypeClientData(SWIGTYPE_p_wxEffects, obj);
21413     Py_INCREF(obj);
21414     return Py_BuildValue((char *)"");
21415 }
21416 static PyMethodDef SwigMethods[] = {
21417          { (char *)"new_GDIObject", (PyCFunction) _wrap_new_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
21418          { (char *)"delete_GDIObject", (PyCFunction) _wrap_delete_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
21419          { (char *)"GDIObject_GetVisible", (PyCFunction) _wrap_GDIObject_GetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
21420          { (char *)"GDIObject_SetVisible", (PyCFunction) _wrap_GDIObject_SetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
21421          { (char *)"GDIObject_IsNull", (PyCFunction) _wrap_GDIObject_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
21422          { (char *)"GDIObject_swigregister", GDIObject_swigregister, METH_VARARGS, NULL},
21423          { (char *)"new_Colour", (PyCFunction) _wrap_new_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
21424          { (char *)"new_NamedColour", (PyCFunction) _wrap_new_NamedColour, METH_VARARGS | METH_KEYWORDS, NULL},
21425          { (char *)"new_ColourRGB", (PyCFunction) _wrap_new_ColourRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21426          { (char *)"delete_Colour", (PyCFunction) _wrap_delete_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
21427          { (char *)"Colour_Red", (PyCFunction) _wrap_Colour_Red, METH_VARARGS | METH_KEYWORDS, NULL},
21428          { (char *)"Colour_Green", (PyCFunction) _wrap_Colour_Green, METH_VARARGS | METH_KEYWORDS, NULL},
21429          { (char *)"Colour_Blue", (PyCFunction) _wrap_Colour_Blue, METH_VARARGS | METH_KEYWORDS, NULL},
21430          { (char *)"Colour_Ok", (PyCFunction) _wrap_Colour_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21431          { (char *)"Colour_Set", (PyCFunction) _wrap_Colour_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21432          { (char *)"Colour_SetRGB", (PyCFunction) _wrap_Colour_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21433          { (char *)"Colour_SetFromName", (PyCFunction) _wrap_Colour_SetFromName, METH_VARARGS | METH_KEYWORDS, NULL},
21434          { (char *)"Colour_GetPixel", (PyCFunction) _wrap_Colour_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
21435          { (char *)"Colour___eq__", (PyCFunction) _wrap_Colour___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21436          { (char *)"Colour___ne__", (PyCFunction) _wrap_Colour___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21437          { (char *)"Colour_Get", (PyCFunction) _wrap_Colour_Get, METH_VARARGS | METH_KEYWORDS, NULL},
21438          { (char *)"Colour_GetRGB", (PyCFunction) _wrap_Colour_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21439          { (char *)"Colour_swigregister", Colour_swigregister, METH_VARARGS, NULL},
21440          { (char *)"new_Palette", (PyCFunction) _wrap_new_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
21441          { (char *)"delete_Palette", (PyCFunction) _wrap_delete_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
21442          { (char *)"Palette_GetPixel", (PyCFunction) _wrap_Palette_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
21443          { (char *)"Palette_GetRGB", (PyCFunction) _wrap_Palette_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21444          { (char *)"Palette_GetColoursCount", (PyCFunction) _wrap_Palette_GetColoursCount, METH_VARARGS | METH_KEYWORDS, NULL},
21445          { (char *)"Palette_Ok", (PyCFunction) _wrap_Palette_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21446          { (char *)"Palette_swigregister", Palette_swigregister, METH_VARARGS, NULL},
21447          { (char *)"new_Pen", (PyCFunction) _wrap_new_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
21448          { (char *)"delete_Pen", (PyCFunction) _wrap_delete_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
21449          { (char *)"Pen_GetCap", (PyCFunction) _wrap_Pen_GetCap, METH_VARARGS | METH_KEYWORDS, NULL},
21450          { (char *)"Pen_GetColour", (PyCFunction) _wrap_Pen_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21451          { (char *)"Pen_GetJoin", (PyCFunction) _wrap_Pen_GetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
21452          { (char *)"Pen_GetStyle", (PyCFunction) _wrap_Pen_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21453          { (char *)"Pen_GetWidth", (PyCFunction) _wrap_Pen_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21454          { (char *)"Pen_Ok", (PyCFunction) _wrap_Pen_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21455          { (char *)"Pen_SetCap", (PyCFunction) _wrap_Pen_SetCap, METH_VARARGS | METH_KEYWORDS, NULL},
21456          { (char *)"Pen_SetColour", (PyCFunction) _wrap_Pen_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21457          { (char *)"Pen_SetJoin", (PyCFunction) _wrap_Pen_SetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
21458          { (char *)"Pen_SetStyle", (PyCFunction) _wrap_Pen_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21459          { (char *)"Pen_SetWidth", (PyCFunction) _wrap_Pen_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21460          { (char *)"Pen_SetDashes", (PyCFunction) _wrap_Pen_SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
21461          { (char *)"Pen_GetDashes", (PyCFunction) _wrap_Pen_GetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
21462          { (char *)"Pen__SetDashes", (PyCFunction) _wrap_Pen__SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
21463          { (char *)"Pen_GetDashCount", (PyCFunction) _wrap_Pen_GetDashCount, METH_VARARGS | METH_KEYWORDS, NULL},
21464          { (char *)"Pen_GetStipple", (PyCFunction) _wrap_Pen_GetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
21465          { (char *)"Pen_SetStipple", (PyCFunction) _wrap_Pen_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
21466          { (char *)"Pen___eq__", (PyCFunction) _wrap_Pen___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21467          { (char *)"Pen___ne__", (PyCFunction) _wrap_Pen___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21468          { (char *)"Pen_swigregister", Pen_swigregister, METH_VARARGS, NULL},
21469          { (char *)"new_Brush", (PyCFunction) _wrap_new_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
21470          { (char *)"delete_Brush", (PyCFunction) _wrap_delete_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
21471          { (char *)"Brush_SetColour", (PyCFunction) _wrap_Brush_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21472          { (char *)"Brush_SetStyle", (PyCFunction) _wrap_Brush_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21473          { (char *)"Brush_SetStipple", (PyCFunction) _wrap_Brush_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
21474          { (char *)"Brush_GetColour", (PyCFunction) _wrap_Brush_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21475          { (char *)"Brush_GetStyle", (PyCFunction) _wrap_Brush_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21476          { (char *)"Brush_GetStipple", (PyCFunction) _wrap_Brush_GetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
21477          { (char *)"Brush_IsHatch", (PyCFunction) _wrap_Brush_IsHatch, METH_VARARGS | METH_KEYWORDS, NULL},
21478          { (char *)"Brush_Ok", (PyCFunction) _wrap_Brush_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21479          { (char *)"Brush_swigregister", Brush_swigregister, METH_VARARGS, NULL},
21480          { (char *)"new_Bitmap", (PyCFunction) _wrap_new_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21481          { (char *)"delete_Bitmap", (PyCFunction) _wrap_delete_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21482          { (char *)"new_EmptyBitmap", (PyCFunction) _wrap_new_EmptyBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21483          { (char *)"new_BitmapFromIcon", (PyCFunction) _wrap_new_BitmapFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21484          { (char *)"new_BitmapFromImage", (PyCFunction) _wrap_new_BitmapFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
21485          { (char *)"new_BitmapFromXPMData", (PyCFunction) _wrap_new_BitmapFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
21486          { (char *)"new_BitmapFromBits", (PyCFunction) _wrap_new_BitmapFromBits, METH_VARARGS | METH_KEYWORDS, NULL},
21487          { (char *)"Bitmap_GetHandle", (PyCFunction) _wrap_Bitmap_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
21488          { (char *)"Bitmap_SetHandle", (PyCFunction) _wrap_Bitmap_SetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
21489          { (char *)"Bitmap_Ok", (PyCFunction) _wrap_Bitmap_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21490          { (char *)"Bitmap_GetWidth", (PyCFunction) _wrap_Bitmap_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21491          { (char *)"Bitmap_GetHeight", (PyCFunction) _wrap_Bitmap_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21492          { (char *)"Bitmap_GetDepth", (PyCFunction) _wrap_Bitmap_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21493          { (char *)"Bitmap_GetSize", (PyCFunction) _wrap_Bitmap_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21494          { (char *)"Bitmap_ConvertToImage", (PyCFunction) _wrap_Bitmap_ConvertToImage, METH_VARARGS | METH_KEYWORDS, NULL},
21495          { (char *)"Bitmap_GetMask", (PyCFunction) _wrap_Bitmap_GetMask, METH_VARARGS | METH_KEYWORDS, NULL},
21496          { (char *)"Bitmap_SetMask", (PyCFunction) _wrap_Bitmap_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
21497          { (char *)"Bitmap_SetMaskColour", (PyCFunction) _wrap_Bitmap_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
21498          { (char *)"Bitmap_GetSubBitmap", (PyCFunction) _wrap_Bitmap_GetSubBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21499          { (char *)"Bitmap_SaveFile", (PyCFunction) _wrap_Bitmap_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
21500          { (char *)"Bitmap_LoadFile", (PyCFunction) _wrap_Bitmap_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
21501          { (char *)"Bitmap_GetPalette", (PyCFunction) _wrap_Bitmap_GetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
21502          { (char *)"Bitmap_SetPalette", (PyCFunction) _wrap_Bitmap_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
21503          { (char *)"Bitmap_CopyFromIcon", (PyCFunction) _wrap_Bitmap_CopyFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21504          { (char *)"Bitmap_SetHeight", (PyCFunction) _wrap_Bitmap_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21505          { (char *)"Bitmap_SetWidth", (PyCFunction) _wrap_Bitmap_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21506          { (char *)"Bitmap_SetDepth", (PyCFunction) _wrap_Bitmap_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21507          { (char *)"Bitmap_SetSize", (PyCFunction) _wrap_Bitmap_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21508          { (char *)"Bitmap_CopyFromCursor", (PyCFunction) _wrap_Bitmap_CopyFromCursor, METH_VARARGS | METH_KEYWORDS, NULL},
21509          { (char *)"Bitmap_GetQuality", (PyCFunction) _wrap_Bitmap_GetQuality, METH_VARARGS | METH_KEYWORDS, NULL},
21510          { (char *)"Bitmap_SetQuality", (PyCFunction) _wrap_Bitmap_SetQuality, METH_VARARGS | METH_KEYWORDS, NULL},
21511          { (char *)"Bitmap___eq__", (PyCFunction) _wrap_Bitmap___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21512          { (char *)"Bitmap___ne__", (PyCFunction) _wrap_Bitmap___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21513          { (char *)"Bitmap_swigregister", Bitmap_swigregister, METH_VARARGS, NULL},
21514          { (char *)"new_Mask", (PyCFunction) _wrap_new_Mask, METH_VARARGS | METH_KEYWORDS, NULL},
21515          { (char *)"Mask_swigregister", Mask_swigregister, METH_VARARGS, NULL},
21516          { (char *)"new_Icon", (PyCFunction) _wrap_new_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
21517          { (char *)"delete_Icon", (PyCFunction) _wrap_delete_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
21518          { (char *)"new_EmptyIcon", (PyCFunction) _wrap_new_EmptyIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21519          { (char *)"new_IconFromLocation", (PyCFunction) _wrap_new_IconFromLocation, METH_VARARGS | METH_KEYWORDS, NULL},
21520          { (char *)"new_IconFromBitmap", (PyCFunction) _wrap_new_IconFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21521          { (char *)"new_IconFromXPMData", (PyCFunction) _wrap_new_IconFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
21522          { (char *)"Icon_LoadFile", (PyCFunction) _wrap_Icon_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
21523          { (char *)"Icon_GetHandle", (PyCFunction) _wrap_Icon_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
21524          { (char *)"Icon_SetHandle", (PyCFunction) _wrap_Icon_SetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
21525          { (char *)"Icon_Ok", (PyCFunction) _wrap_Icon_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21526          { (char *)"Icon_GetWidth", (PyCFunction) _wrap_Icon_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21527          { (char *)"Icon_GetHeight", (PyCFunction) _wrap_Icon_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21528          { (char *)"Icon_GetDepth", (PyCFunction) _wrap_Icon_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21529          { (char *)"Icon_SetWidth", (PyCFunction) _wrap_Icon_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21530          { (char *)"Icon_SetHeight", (PyCFunction) _wrap_Icon_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21531          { (char *)"Icon_SetDepth", (PyCFunction) _wrap_Icon_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21532          { (char *)"Icon_SetSize", (PyCFunction) _wrap_Icon_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21533          { (char *)"Icon_CopyFromBitmap", (PyCFunction) _wrap_Icon_CopyFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21534          { (char *)"Icon_swigregister", Icon_swigregister, METH_VARARGS, NULL},
21535          { (char *)"new_IconLocation", (PyCFunction) _wrap_new_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
21536          { (char *)"delete_IconLocation", (PyCFunction) _wrap_delete_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
21537          { (char *)"IconLocation_IsOk", (PyCFunction) _wrap_IconLocation_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
21538          { (char *)"IconLocation_SetFileName", (PyCFunction) _wrap_IconLocation_SetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
21539          { (char *)"IconLocation_GetFileName", (PyCFunction) _wrap_IconLocation_GetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
21540          { (char *)"IconLocation_SetIndex", (PyCFunction) _wrap_IconLocation_SetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
21541          { (char *)"IconLocation_GetIndex", (PyCFunction) _wrap_IconLocation_GetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
21542          { (char *)"IconLocation_swigregister", IconLocation_swigregister, METH_VARARGS, NULL},
21543          { (char *)"new_IconBundle", (PyCFunction) _wrap_new_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
21544          { (char *)"new_IconBundleFromFile", (PyCFunction) _wrap_new_IconBundleFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
21545          { (char *)"new_IconBundleFromIcon", (PyCFunction) _wrap_new_IconBundleFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21546          { (char *)"delete_IconBundle", (PyCFunction) _wrap_delete_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
21547          { (char *)"IconBundle_AddIcon", (PyCFunction) _wrap_IconBundle_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21548          { (char *)"IconBundle_AddIconFromFile", (PyCFunction) _wrap_IconBundle_AddIconFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
21549          { (char *)"IconBundle_GetIcon", (PyCFunction) _wrap_IconBundle_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21550          { (char *)"IconBundle_swigregister", IconBundle_swigregister, METH_VARARGS, NULL},
21551          { (char *)"new_Cursor", (PyCFunction) _wrap_new_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
21552          { (char *)"delete_Cursor", (PyCFunction) _wrap_delete_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
21553          { (char *)"new_StockCursor", (PyCFunction) _wrap_new_StockCursor, METH_VARARGS | METH_KEYWORDS, NULL},
21554          { (char *)"new_CursorFromImage", (PyCFunction) _wrap_new_CursorFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
21555          { (char *)"Cursor_GetHandle", (PyCFunction) _wrap_Cursor_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
21556          { (char *)"Cursor_SetHandle", (PyCFunction) _wrap_Cursor_SetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
21557          { (char *)"Cursor_Ok", (PyCFunction) _wrap_Cursor_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21558          { (char *)"Cursor_GetWidth", (PyCFunction) _wrap_Cursor_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21559          { (char *)"Cursor_GetHeight", (PyCFunction) _wrap_Cursor_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21560          { (char *)"Cursor_GetDepth", (PyCFunction) _wrap_Cursor_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21561          { (char *)"Cursor_SetWidth", (PyCFunction) _wrap_Cursor_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21562          { (char *)"Cursor_SetHeight", (PyCFunction) _wrap_Cursor_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21563          { (char *)"Cursor_SetDepth", (PyCFunction) _wrap_Cursor_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21564          { (char *)"Cursor_SetSize", (PyCFunction) _wrap_Cursor_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21565          { (char *)"Cursor_swigregister", Cursor_swigregister, METH_VARARGS, NULL},
21566          { (char *)"new_Region", (PyCFunction) _wrap_new_Region, METH_VARARGS | METH_KEYWORDS, NULL},
21567          { (char *)"new_RegionFromBitmap", (PyCFunction) _wrap_new_RegionFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21568          { (char *)"new_RegionFromBitmapColour", (PyCFunction) _wrap_new_RegionFromBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
21569          { (char *)"new_RegionFromPoints", (PyCFunction) _wrap_new_RegionFromPoints, METH_VARARGS | METH_KEYWORDS, NULL},
21570          { (char *)"delete_Region", (PyCFunction) _wrap_delete_Region, METH_VARARGS | METH_KEYWORDS, NULL},
21571          { (char *)"Region_Clear", (PyCFunction) _wrap_Region_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
21572          { (char *)"Region_Offset", (PyCFunction) _wrap_Region_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
21573          { (char *)"Region_Contains", (PyCFunction) _wrap_Region_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
21574          { (char *)"Region_ContainsPoint", (PyCFunction) _wrap_Region_ContainsPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21575          { (char *)"Region_ContainsRect", (PyCFunction) _wrap_Region_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
21576          { (char *)"Region_ContainsRectDim", (PyCFunction) _wrap_Region_ContainsRectDim, METH_VARARGS | METH_KEYWORDS, NULL},
21577          { (char *)"Region_GetBox", (PyCFunction) _wrap_Region_GetBox, METH_VARARGS | METH_KEYWORDS, NULL},
21578          { (char *)"Region_Intersect", (PyCFunction) _wrap_Region_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
21579          { (char *)"Region_IntersectRect", (PyCFunction) _wrap_Region_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
21580          { (char *)"Region_IntersectRegion", (PyCFunction) _wrap_Region_IntersectRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21581          { (char *)"Region_IsEmpty", (PyCFunction) _wrap_Region_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
21582          { (char *)"Region_Union", (PyCFunction) _wrap_Region_Union, METH_VARARGS | METH_KEYWORDS, NULL},
21583          { (char *)"Region_UnionRect", (PyCFunction) _wrap_Region_UnionRect, METH_VARARGS | METH_KEYWORDS, NULL},
21584          { (char *)"Region_UnionRegion", (PyCFunction) _wrap_Region_UnionRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21585          { (char *)"Region_Subtract", (PyCFunction) _wrap_Region_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
21586          { (char *)"Region_SubtractRect", (PyCFunction) _wrap_Region_SubtractRect, METH_VARARGS | METH_KEYWORDS, NULL},
21587          { (char *)"Region_SubtractRegion", (PyCFunction) _wrap_Region_SubtractRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21588          { (char *)"Region_Xor", (PyCFunction) _wrap_Region_Xor, METH_VARARGS | METH_KEYWORDS, NULL},
21589          { (char *)"Region_XorRect", (PyCFunction) _wrap_Region_XorRect, METH_VARARGS | METH_KEYWORDS, NULL},
21590          { (char *)"Region_XorRegion", (PyCFunction) _wrap_Region_XorRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21591          { (char *)"Region_ConvertToBitmap", (PyCFunction) _wrap_Region_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21592          { (char *)"Region_UnionBitmap", (PyCFunction) _wrap_Region_UnionBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21593          { (char *)"Region_UnionBitmapColour", (PyCFunction) _wrap_Region_UnionBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
21594          { (char *)"Region_swigregister", Region_swigregister, METH_VARARGS, NULL},
21595          { (char *)"new_RegionIterator", (PyCFunction) _wrap_new_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
21596          { (char *)"delete_RegionIterator", (PyCFunction) _wrap_delete_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
21597          { (char *)"RegionIterator_GetX", (PyCFunction) _wrap_RegionIterator_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
21598          { (char *)"RegionIterator_GetY", (PyCFunction) _wrap_RegionIterator_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
21599          { (char *)"RegionIterator_GetW", (PyCFunction) _wrap_RegionIterator_GetW, METH_VARARGS | METH_KEYWORDS, NULL},
21600          { (char *)"RegionIterator_GetWidth", (PyCFunction) _wrap_RegionIterator_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21601          { (char *)"RegionIterator_GetH", (PyCFunction) _wrap_RegionIterator_GetH, METH_VARARGS | METH_KEYWORDS, NULL},
21602          { (char *)"RegionIterator_GetHeight", (PyCFunction) _wrap_RegionIterator_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21603          { (char *)"RegionIterator_GetRect", (PyCFunction) _wrap_RegionIterator_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
21604          { (char *)"RegionIterator_HaveRects", (PyCFunction) _wrap_RegionIterator_HaveRects, METH_VARARGS | METH_KEYWORDS, NULL},
21605          { (char *)"RegionIterator_Reset", (PyCFunction) _wrap_RegionIterator_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
21606          { (char *)"RegionIterator_Next", (PyCFunction) _wrap_RegionIterator_Next, METH_VARARGS | METH_KEYWORDS, NULL},
21607          { (char *)"RegionIterator___nonzero__", (PyCFunction) _wrap_RegionIterator___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
21608          { (char *)"RegionIterator_swigregister", RegionIterator_swigregister, METH_VARARGS, NULL},
21609          { (char *)"new_NativeFontInfo", (PyCFunction) _wrap_new_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21610          { (char *)"delete_NativeFontInfo", (PyCFunction) _wrap_delete_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21611          { (char *)"NativeFontInfo_Init", (PyCFunction) _wrap_NativeFontInfo_Init, METH_VARARGS | METH_KEYWORDS, NULL},
21612          { (char *)"NativeFontInfo_InitFromFont", (PyCFunction) _wrap_NativeFontInfo_InitFromFont, METH_VARARGS | METH_KEYWORDS, NULL},
21613          { (char *)"NativeFontInfo_GetPointSize", (PyCFunction) _wrap_NativeFontInfo_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21614          { (char *)"NativeFontInfo_GetPixelSize", (PyCFunction) _wrap_NativeFontInfo_GetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21615          { (char *)"NativeFontInfo_GetStyle", (PyCFunction) _wrap_NativeFontInfo_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21616          { (char *)"NativeFontInfo_GetWeight", (PyCFunction) _wrap_NativeFontInfo_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21617          { (char *)"NativeFontInfo_GetUnderlined", (PyCFunction) _wrap_NativeFontInfo_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21618          { (char *)"NativeFontInfo_GetFaceName", (PyCFunction) _wrap_NativeFontInfo_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21619          { (char *)"NativeFontInfo_GetFamily", (PyCFunction) _wrap_NativeFontInfo_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21620          { (char *)"NativeFontInfo_GetEncoding", (PyCFunction) _wrap_NativeFontInfo_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21621          { (char *)"NativeFontInfo_SetPointSize", (PyCFunction) _wrap_NativeFontInfo_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21622          { (char *)"NativeFontInfo_SetPixelSize", (PyCFunction) _wrap_NativeFontInfo_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21623          { (char *)"NativeFontInfo_SetStyle", (PyCFunction) _wrap_NativeFontInfo_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21624          { (char *)"NativeFontInfo_SetWeight", (PyCFunction) _wrap_NativeFontInfo_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21625          { (char *)"NativeFontInfo_SetUnderlined", (PyCFunction) _wrap_NativeFontInfo_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21626          { (char *)"NativeFontInfo_SetFaceName", (PyCFunction) _wrap_NativeFontInfo_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21627          { (char *)"NativeFontInfo_SetFamily", (PyCFunction) _wrap_NativeFontInfo_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21628          { (char *)"NativeFontInfo_SetEncoding", (PyCFunction) _wrap_NativeFontInfo_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21629          { (char *)"NativeFontInfo_FromString", (PyCFunction) _wrap_NativeFontInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
21630          { (char *)"NativeFontInfo_ToString", (PyCFunction) _wrap_NativeFontInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
21631          { (char *)"NativeFontInfo___str__", (PyCFunction) _wrap_NativeFontInfo___str__, METH_VARARGS | METH_KEYWORDS, NULL},
21632          { (char *)"NativeFontInfo_FromUserString", (PyCFunction) _wrap_NativeFontInfo_FromUserString, METH_VARARGS | METH_KEYWORDS, NULL},
21633          { (char *)"NativeFontInfo_ToUserString", (PyCFunction) _wrap_NativeFontInfo_ToUserString, METH_VARARGS | METH_KEYWORDS, NULL},
21634          { (char *)"NativeFontInfo_swigregister", NativeFontInfo_swigregister, METH_VARARGS, NULL},
21635          { (char *)"NativeEncodingInfo_facename_set", (PyCFunction) _wrap_NativeEncodingInfo_facename_set, METH_VARARGS | METH_KEYWORDS, NULL},
21636          { (char *)"NativeEncodingInfo_facename_get", (PyCFunction) _wrap_NativeEncodingInfo_facename_get, METH_VARARGS | METH_KEYWORDS, NULL},
21637          { (char *)"NativeEncodingInfo_encoding_set", (PyCFunction) _wrap_NativeEncodingInfo_encoding_set, METH_VARARGS | METH_KEYWORDS, NULL},
21638          { (char *)"NativeEncodingInfo_encoding_get", (PyCFunction) _wrap_NativeEncodingInfo_encoding_get, METH_VARARGS | METH_KEYWORDS, NULL},
21639          { (char *)"new_NativeEncodingInfo", (PyCFunction) _wrap_new_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21640          { (char *)"delete_NativeEncodingInfo", (PyCFunction) _wrap_delete_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21641          { (char *)"NativeEncodingInfo_FromString", (PyCFunction) _wrap_NativeEncodingInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
21642          { (char *)"NativeEncodingInfo_ToString", (PyCFunction) _wrap_NativeEncodingInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
21643          { (char *)"NativeEncodingInfo_swigregister", NativeEncodingInfo_swigregister, METH_VARARGS, NULL},
21644          { (char *)"GetNativeFontEncoding", (PyCFunction) _wrap_GetNativeFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21645          { (char *)"TestFontEncoding", (PyCFunction) _wrap_TestFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21646          { (char *)"new_FontMapper", (PyCFunction) _wrap_new_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
21647          { (char *)"delete_FontMapper", (PyCFunction) _wrap_delete_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
21648          { (char *)"FontMapper_Get", (PyCFunction) _wrap_FontMapper_Get, METH_VARARGS | METH_KEYWORDS, NULL},
21649          { (char *)"FontMapper_Set", (PyCFunction) _wrap_FontMapper_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21650          { (char *)"FontMapper_CharsetToEncoding", (PyCFunction) _wrap_FontMapper_CharsetToEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21651          { (char *)"FontMapper_GetSupportedEncodingsCount", (PyCFunction) _wrap_FontMapper_GetSupportedEncodingsCount, METH_VARARGS | METH_KEYWORDS, NULL},
21652          { (char *)"FontMapper_GetEncoding", (PyCFunction) _wrap_FontMapper_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21653          { (char *)"FontMapper_GetEncodingName", (PyCFunction) _wrap_FontMapper_GetEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
21654          { (char *)"FontMapper_GetEncodingDescription", (PyCFunction) _wrap_FontMapper_GetEncodingDescription, METH_VARARGS | METH_KEYWORDS, NULL},
21655          { (char *)"FontMapper_GetEncodingFromName", (PyCFunction) _wrap_FontMapper_GetEncodingFromName, METH_VARARGS | METH_KEYWORDS, NULL},
21656          { (char *)"FontMapper_SetConfig", (PyCFunction) _wrap_FontMapper_SetConfig, METH_VARARGS | METH_KEYWORDS, NULL},
21657          { (char *)"FontMapper_SetConfigPath", (PyCFunction) _wrap_FontMapper_SetConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
21658          { (char *)"FontMapper_GetDefaultConfigPath", (PyCFunction) _wrap_FontMapper_GetDefaultConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
21659          { (char *)"FontMapper_GetAltForEncoding", (PyCFunction) _wrap_FontMapper_GetAltForEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21660          { (char *)"FontMapper_IsEncodingAvailable", (PyCFunction) _wrap_FontMapper_IsEncodingAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
21661          { (char *)"FontMapper_SetDialogParent", (PyCFunction) _wrap_FontMapper_SetDialogParent, METH_VARARGS | METH_KEYWORDS, NULL},
21662          { (char *)"FontMapper_SetDialogTitle", (PyCFunction) _wrap_FontMapper_SetDialogTitle, METH_VARARGS | METH_KEYWORDS, NULL},
21663          { (char *)"FontMapper_swigregister", FontMapper_swigregister, METH_VARARGS, NULL},
21664          { (char *)"new_Font", (PyCFunction) _wrap_new_Font, METH_VARARGS | METH_KEYWORDS, NULL},
21665          { (char *)"delete_Font", (PyCFunction) _wrap_delete_Font, METH_VARARGS | METH_KEYWORDS, NULL},
21666          { (char *)"new_FontFromNativeInfo", (PyCFunction) _wrap_new_FontFromNativeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21667          { (char *)"new_FontFromNativeInfoString", (PyCFunction) _wrap_new_FontFromNativeInfoString, METH_VARARGS | METH_KEYWORDS, NULL},
21668          { (char *)"new_Font2", (PyCFunction) _wrap_new_Font2, METH_VARARGS | METH_KEYWORDS, NULL},
21669          { (char *)"new_FontFromPixelSize", (PyCFunction) _wrap_new_FontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21670          { (char *)"Font_Ok", (PyCFunction) _wrap_Font_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21671          { (char *)"Font___eq__", (PyCFunction) _wrap_Font___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21672          { (char *)"Font___ne__", (PyCFunction) _wrap_Font___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21673          { (char *)"Font_GetPointSize", (PyCFunction) _wrap_Font_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21674          { (char *)"Font_GetPixelSize", (PyCFunction) _wrap_Font_GetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21675          { (char *)"Font_IsUsingSizeInPixels", (PyCFunction) _wrap_Font_IsUsingSizeInPixels, METH_VARARGS | METH_KEYWORDS, NULL},
21676          { (char *)"Font_GetFamily", (PyCFunction) _wrap_Font_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21677          { (char *)"Font_GetStyle", (PyCFunction) _wrap_Font_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21678          { (char *)"Font_GetWeight", (PyCFunction) _wrap_Font_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21679          { (char *)"Font_GetUnderlined", (PyCFunction) _wrap_Font_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21680          { (char *)"Font_GetFaceName", (PyCFunction) _wrap_Font_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21681          { (char *)"Font_GetEncoding", (PyCFunction) _wrap_Font_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21682          { (char *)"Font_GetNativeFontInfo", (PyCFunction) _wrap_Font_GetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21683          { (char *)"Font_IsFixedWidth", (PyCFunction) _wrap_Font_IsFixedWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21684          { (char *)"Font_GetNativeFontInfoDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoDesc, METH_VARARGS | METH_KEYWORDS, NULL},
21685          { (char *)"Font_GetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
21686          { (char *)"Font_SetPointSize", (PyCFunction) _wrap_Font_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21687          { (char *)"Font_SetPixelSize", (PyCFunction) _wrap_Font_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21688          { (char *)"Font_SetFamily", (PyCFunction) _wrap_Font_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21689          { (char *)"Font_SetStyle", (PyCFunction) _wrap_Font_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21690          { (char *)"Font_SetWeight", (PyCFunction) _wrap_Font_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21691          { (char *)"Font_SetFaceName", (PyCFunction) _wrap_Font_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21692          { (char *)"Font_SetUnderlined", (PyCFunction) _wrap_Font_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21693          { (char *)"Font_SetEncoding", (PyCFunction) _wrap_Font_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21694          { (char *)"Font_SetNativeFontInfo", (PyCFunction) _wrap_Font_SetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21695          { (char *)"Font_SetNativeFontInfoFromString", (PyCFunction) _wrap_Font_SetNativeFontInfoFromString, METH_VARARGS | METH_KEYWORDS, NULL},
21696          { (char *)"Font_SetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_SetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
21697          { (char *)"Font_GetFamilyString", (PyCFunction) _wrap_Font_GetFamilyString, METH_VARARGS | METH_KEYWORDS, NULL},
21698          { (char *)"Font_GetStyleString", (PyCFunction) _wrap_Font_GetStyleString, METH_VARARGS | METH_KEYWORDS, NULL},
21699          { (char *)"Font_GetWeightString", (PyCFunction) _wrap_Font_GetWeightString, METH_VARARGS | METH_KEYWORDS, NULL},
21700          { (char *)"Font_SetNoAntiAliasing", (PyCFunction) _wrap_Font_SetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
21701          { (char *)"Font_GetNoAntiAliasing", (PyCFunction) _wrap_Font_GetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
21702          { (char *)"Font_GetDefaultEncoding", (PyCFunction) _wrap_Font_GetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21703          { (char *)"Font_SetDefaultEncoding", (PyCFunction) _wrap_Font_SetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21704          { (char *)"Font_swigregister", Font_swigregister, METH_VARARGS, NULL},
21705          { (char *)"new_FontEnumerator", (PyCFunction) _wrap_new_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
21706          { (char *)"delete_FontEnumerator", (PyCFunction) _wrap_delete_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
21707          { (char *)"FontEnumerator__setCallbackInfo", (PyCFunction) _wrap_FontEnumerator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21708          { (char *)"FontEnumerator_EnumerateFacenames", (PyCFunction) _wrap_FontEnumerator_EnumerateFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
21709          { (char *)"FontEnumerator_EnumerateEncodings", (PyCFunction) _wrap_FontEnumerator_EnumerateEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
21710          { (char *)"FontEnumerator_GetEncodings", (PyCFunction) _wrap_FontEnumerator_GetEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
21711          { (char *)"FontEnumerator_GetFacenames", (PyCFunction) _wrap_FontEnumerator_GetFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
21712          { (char *)"FontEnumerator_swigregister", FontEnumerator_swigregister, METH_VARARGS, NULL},
21713          { (char *)"LanguageInfo_Language_set", (PyCFunction) _wrap_LanguageInfo_Language_set, METH_VARARGS | METH_KEYWORDS, NULL},
21714          { (char *)"LanguageInfo_Language_get", (PyCFunction) _wrap_LanguageInfo_Language_get, METH_VARARGS | METH_KEYWORDS, NULL},
21715          { (char *)"LanguageInfo_CanonicalName_set", (PyCFunction) _wrap_LanguageInfo_CanonicalName_set, METH_VARARGS | METH_KEYWORDS, NULL},
21716          { (char *)"LanguageInfo_CanonicalName_get", (PyCFunction) _wrap_LanguageInfo_CanonicalName_get, METH_VARARGS | METH_KEYWORDS, NULL},
21717          { (char *)"LanguageInfo_Description_set", (PyCFunction) _wrap_LanguageInfo_Description_set, METH_VARARGS | METH_KEYWORDS, NULL},
21718          { (char *)"LanguageInfo_Description_get", (PyCFunction) _wrap_LanguageInfo_Description_get, METH_VARARGS | METH_KEYWORDS, NULL},
21719          { (char *)"LanguageInfo_swigregister", LanguageInfo_swigregister, METH_VARARGS, NULL},
21720          { (char *)"new_Locale", (PyCFunction) _wrap_new_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
21721          { (char *)"delete_Locale", (PyCFunction) _wrap_delete_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
21722          { (char *)"Locale_Init1", (PyCFunction) _wrap_Locale_Init1, METH_VARARGS | METH_KEYWORDS, NULL},
21723          { (char *)"Locale_Init2", (PyCFunction) _wrap_Locale_Init2, METH_VARARGS | METH_KEYWORDS, NULL},
21724          { (char *)"Locale_GetSystemLanguage", (PyCFunction) _wrap_Locale_GetSystemLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
21725          { (char *)"Locale_GetSystemEncoding", (PyCFunction) _wrap_Locale_GetSystemEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21726          { (char *)"Locale_GetSystemEncodingName", (PyCFunction) _wrap_Locale_GetSystemEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
21727          { (char *)"Locale_IsOk", (PyCFunction) _wrap_Locale_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
21728          { (char *)"Locale_GetLocale", (PyCFunction) _wrap_Locale_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
21729          { (char *)"Locale_GetLanguage", (PyCFunction) _wrap_Locale_GetLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
21730          { (char *)"Locale_GetSysName", (PyCFunction) _wrap_Locale_GetSysName, METH_VARARGS | METH_KEYWORDS, NULL},
21731          { (char *)"Locale_GetCanonicalName", (PyCFunction) _wrap_Locale_GetCanonicalName, METH_VARARGS | METH_KEYWORDS, NULL},
21732          { (char *)"Locale_AddCatalogLookupPathPrefix", (PyCFunction) _wrap_Locale_AddCatalogLookupPathPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
21733          { (char *)"Locale_AddCatalog", (PyCFunction) _wrap_Locale_AddCatalog, METH_VARARGS | METH_KEYWORDS, NULL},
21734          { (char *)"Locale_IsLoaded", (PyCFunction) _wrap_Locale_IsLoaded, METH_VARARGS | METH_KEYWORDS, NULL},
21735          { (char *)"Locale_GetLanguageInfo", (PyCFunction) _wrap_Locale_GetLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21736          { (char *)"Locale_GetLanguageName", (PyCFunction) _wrap_Locale_GetLanguageName, METH_VARARGS | METH_KEYWORDS, NULL},
21737          { (char *)"Locale_FindLanguageInfo", (PyCFunction) _wrap_Locale_FindLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21738          { (char *)"Locale_AddLanguage", (PyCFunction) _wrap_Locale_AddLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
21739          { (char *)"Locale_GetString", (PyCFunction) _wrap_Locale_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
21740          { (char *)"Locale_GetName", (PyCFunction) _wrap_Locale_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
21741          { (char *)"Locale_swigregister", Locale_swigregister, METH_VARARGS, NULL},
21742          { (char *)"GetLocale", (PyCFunction) _wrap_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
21743          { (char *)"GetTranslation", _wrap_GetTranslation, METH_VARARGS, NULL},
21744          { (char *)"new_EncodingConverter", (PyCFunction) _wrap_new_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
21745          { (char *)"delete_EncodingConverter", (PyCFunction) _wrap_delete_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
21746          { (char *)"EncodingConverter_Init", (PyCFunction) _wrap_EncodingConverter_Init, METH_VARARGS | METH_KEYWORDS, NULL},
21747          { (char *)"EncodingConverter_Convert", (PyCFunction) _wrap_EncodingConverter_Convert, METH_VARARGS | METH_KEYWORDS, NULL},
21748          { (char *)"EncodingConverter_GetPlatformEquivalents", (PyCFunction) _wrap_EncodingConverter_GetPlatformEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
21749          { (char *)"EncodingConverter_GetAllEquivalents", (PyCFunction) _wrap_EncodingConverter_GetAllEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
21750          { (char *)"EncodingConverter_CanConvert", (PyCFunction) _wrap_EncodingConverter_CanConvert, METH_VARARGS | METH_KEYWORDS, NULL},
21751          { (char *)"EncodingConverter_swigregister", EncodingConverter_swigregister, METH_VARARGS, NULL},
21752          { (char *)"delete_DC", (PyCFunction) _wrap_delete_DC, METH_VARARGS | METH_KEYWORDS, NULL},
21753          { (char *)"DC_BeginDrawing", (PyCFunction) _wrap_DC_BeginDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
21754          { (char *)"DC_EndDrawing", (PyCFunction) _wrap_DC_EndDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
21755          { (char *)"DC_FloodFill", (PyCFunction) _wrap_DC_FloodFill, METH_VARARGS | METH_KEYWORDS, NULL},
21756          { (char *)"DC_FloodFillPoint", (PyCFunction) _wrap_DC_FloodFillPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21757          { (char *)"DC_GetPixel", (PyCFunction) _wrap_DC_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
21758          { (char *)"DC_GetPixelPoint", (PyCFunction) _wrap_DC_GetPixelPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21759          { (char *)"DC_DrawLine", (PyCFunction) _wrap_DC_DrawLine, METH_VARARGS | METH_KEYWORDS, NULL},
21760          { (char *)"DC_DrawLinePoint", (PyCFunction) _wrap_DC_DrawLinePoint, METH_VARARGS | METH_KEYWORDS, NULL},
21761          { (char *)"DC_CrossHair", (PyCFunction) _wrap_DC_CrossHair, METH_VARARGS | METH_KEYWORDS, NULL},
21762          { (char *)"DC_CrossHairPoint", (PyCFunction) _wrap_DC_CrossHairPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21763          { (char *)"DC_DrawArc", (PyCFunction) _wrap_DC_DrawArc, METH_VARARGS | METH_KEYWORDS, NULL},
21764          { (char *)"DC_DrawArcPoint", (PyCFunction) _wrap_DC_DrawArcPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21765          { (char *)"DC_DrawCheckMark", (PyCFunction) _wrap_DC_DrawCheckMark, METH_VARARGS | METH_KEYWORDS, NULL},
21766          { (char *)"DC_DrawCheckMarkRect", (PyCFunction) _wrap_DC_DrawCheckMarkRect, METH_VARARGS | METH_KEYWORDS, NULL},
21767          { (char *)"DC_DrawEllipticArc", (PyCFunction) _wrap_DC_DrawEllipticArc, METH_VARARGS | METH_KEYWORDS, NULL},
21768          { (char *)"DC_DrawEllipticArcPointSize", (PyCFunction) _wrap_DC_DrawEllipticArcPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21769          { (char *)"DC_DrawPoint", (PyCFunction) _wrap_DC_DrawPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21770          { (char *)"DC_DrawPointPoint", (PyCFunction) _wrap_DC_DrawPointPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21771          { (char *)"DC_DrawRectangle", (PyCFunction) _wrap_DC_DrawRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
21772          { (char *)"DC_DrawRectangleRect", (PyCFunction) _wrap_DC_DrawRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
21773          { (char *)"DC_DrawRectanglePointSize", (PyCFunction) _wrap_DC_DrawRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21774          { (char *)"DC_DrawRoundedRectangle", (PyCFunction) _wrap_DC_DrawRoundedRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
21775          { (char *)"DC_DrawRoundedRectangleRect", (PyCFunction) _wrap_DC_DrawRoundedRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
21776          { (char *)"DC_DrawRoundedRectanglePointSize", (PyCFunction) _wrap_DC_DrawRoundedRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21777          { (char *)"DC_DrawCircle", (PyCFunction) _wrap_DC_DrawCircle, METH_VARARGS | METH_KEYWORDS, NULL},
21778          { (char *)"DC_DrawCirclePoint", (PyCFunction) _wrap_DC_DrawCirclePoint, METH_VARARGS | METH_KEYWORDS, NULL},
21779          { (char *)"DC_DrawEllipse", (PyCFunction) _wrap_DC_DrawEllipse, METH_VARARGS | METH_KEYWORDS, NULL},
21780          { (char *)"DC_DrawEllipseRect", (PyCFunction) _wrap_DC_DrawEllipseRect, METH_VARARGS | METH_KEYWORDS, NULL},
21781          { (char *)"DC_DrawEllipsePointSize", (PyCFunction) _wrap_DC_DrawEllipsePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21782          { (char *)"DC_DrawIcon", (PyCFunction) _wrap_DC_DrawIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21783          { (char *)"DC_DrawIconPoint", (PyCFunction) _wrap_DC_DrawIconPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21784          { (char *)"DC_DrawBitmap", (PyCFunction) _wrap_DC_DrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21785          { (char *)"DC_DrawBitmapPoint", (PyCFunction) _wrap_DC_DrawBitmapPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21786          { (char *)"DC_DrawText", (PyCFunction) _wrap_DC_DrawText, METH_VARARGS | METH_KEYWORDS, NULL},
21787          { (char *)"DC_DrawTextPoint", (PyCFunction) _wrap_DC_DrawTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21788          { (char *)"DC_DrawRotatedText", (PyCFunction) _wrap_DC_DrawRotatedText, METH_VARARGS | METH_KEYWORDS, NULL},
21789          { (char *)"DC_DrawRotatedTextPoint", (PyCFunction) _wrap_DC_DrawRotatedTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21790          { (char *)"DC_Blit", (PyCFunction) _wrap_DC_Blit, METH_VARARGS | METH_KEYWORDS, NULL},
21791          { (char *)"DC_BlitPointSize", (PyCFunction) _wrap_DC_BlitPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21792          { (char *)"DC_SetClippingRegion", (PyCFunction) _wrap_DC_SetClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21793          { (char *)"DC_SetClippingRegionPointSize", (PyCFunction) _wrap_DC_SetClippingRegionPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21794          { (char *)"DC_SetClippingRegionAsRegion", (PyCFunction) _wrap_DC_SetClippingRegionAsRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21795          { (char *)"DC_SetClippingRect", (PyCFunction) _wrap_DC_SetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
21796          { (char *)"DC_DrawLines", (PyCFunction) _wrap_DC_DrawLines, METH_VARARGS | METH_KEYWORDS, NULL},
21797          { (char *)"DC_DrawPolygon", (PyCFunction) _wrap_DC_DrawPolygon, METH_VARARGS | METH_KEYWORDS, NULL},
21798          { (char *)"DC_DrawLabel", (PyCFunction) _wrap_DC_DrawLabel, METH_VARARGS | METH_KEYWORDS, NULL},
21799          { (char *)"DC_DrawImageLabel", (PyCFunction) _wrap_DC_DrawImageLabel, METH_VARARGS | METH_KEYWORDS, NULL},
21800          { (char *)"DC_DrawSpline", (PyCFunction) _wrap_DC_DrawSpline, METH_VARARGS | METH_KEYWORDS, NULL},
21801          { (char *)"DC_Clear", (PyCFunction) _wrap_DC_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
21802          { (char *)"DC_StartDoc", (PyCFunction) _wrap_DC_StartDoc, METH_VARARGS | METH_KEYWORDS, NULL},
21803          { (char *)"DC_EndDoc", (PyCFunction) _wrap_DC_EndDoc, METH_VARARGS | METH_KEYWORDS, NULL},
21804          { (char *)"DC_StartPage", (PyCFunction) _wrap_DC_StartPage, METH_VARARGS | METH_KEYWORDS, NULL},
21805          { (char *)"DC_EndPage", (PyCFunction) _wrap_DC_EndPage, METH_VARARGS | METH_KEYWORDS, NULL},
21806          { (char *)"DC_SetFont", (PyCFunction) _wrap_DC_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
21807          { (char *)"DC_SetPen", (PyCFunction) _wrap_DC_SetPen, METH_VARARGS | METH_KEYWORDS, NULL},
21808          { (char *)"DC_SetBrush", (PyCFunction) _wrap_DC_SetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21809          { (char *)"DC_SetBackground", (PyCFunction) _wrap_DC_SetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21810          { (char *)"DC_SetBackgroundMode", (PyCFunction) _wrap_DC_SetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
21811          { (char *)"DC_SetPalette", (PyCFunction) _wrap_DC_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
21812          { (char *)"DC_DestroyClippingRegion", (PyCFunction) _wrap_DC_DestroyClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21813          { (char *)"DC_GetClippingBox", (PyCFunction) _wrap_DC_GetClippingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21814          { (char *)"DC_GetClippingRect", (PyCFunction) _wrap_DC_GetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
21815          { (char *)"DC_GetCharHeight", (PyCFunction) _wrap_DC_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21816          { (char *)"DC_GetCharWidth", (PyCFunction) _wrap_DC_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21817          { (char *)"DC_GetTextExtent", (PyCFunction) _wrap_DC_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21818          { (char *)"DC_GetFullTextExtent", (PyCFunction) _wrap_DC_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21819          { (char *)"DC_GetMultiLineTextExtent", (PyCFunction) _wrap_DC_GetMultiLineTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21820          { (char *)"DC_GetPartialTextExtents", (PyCFunction) _wrap_DC_GetPartialTextExtents, METH_VARARGS | METH_KEYWORDS, NULL},
21821          { (char *)"DC_GetSize", (PyCFunction) _wrap_DC_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21822          { (char *)"DC_GetSizeTuple", (PyCFunction) _wrap_DC_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21823          { (char *)"DC_GetSizeMM", (PyCFunction) _wrap_DC_GetSizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
21824          { (char *)"DC_GetSizeMMTuple", (PyCFunction) _wrap_DC_GetSizeMMTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21825          { (char *)"DC_DeviceToLogicalX", (PyCFunction) _wrap_DC_DeviceToLogicalX, METH_VARARGS | METH_KEYWORDS, NULL},
21826          { (char *)"DC_DeviceToLogicalY", (PyCFunction) _wrap_DC_DeviceToLogicalY, METH_VARARGS | METH_KEYWORDS, NULL},
21827          { (char *)"DC_DeviceToLogicalXRel", (PyCFunction) _wrap_DC_DeviceToLogicalXRel, METH_VARARGS | METH_KEYWORDS, NULL},
21828          { (char *)"DC_DeviceToLogicalYRel", (PyCFunction) _wrap_DC_DeviceToLogicalYRel, METH_VARARGS | METH_KEYWORDS, NULL},
21829          { (char *)"DC_LogicalToDeviceX", (PyCFunction) _wrap_DC_LogicalToDeviceX, METH_VARARGS | METH_KEYWORDS, NULL},
21830          { (char *)"DC_LogicalToDeviceY", (PyCFunction) _wrap_DC_LogicalToDeviceY, METH_VARARGS | METH_KEYWORDS, NULL},
21831          { (char *)"DC_LogicalToDeviceXRel", (PyCFunction) _wrap_DC_LogicalToDeviceXRel, METH_VARARGS | METH_KEYWORDS, NULL},
21832          { (char *)"DC_LogicalToDeviceYRel", (PyCFunction) _wrap_DC_LogicalToDeviceYRel, METH_VARARGS | METH_KEYWORDS, NULL},
21833          { (char *)"DC_CanDrawBitmap", (PyCFunction) _wrap_DC_CanDrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21834          { (char *)"DC_CanGetTextExtent", (PyCFunction) _wrap_DC_CanGetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21835          { (char *)"DC_GetDepth", (PyCFunction) _wrap_DC_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21836          { (char *)"DC_GetPPI", (PyCFunction) _wrap_DC_GetPPI, METH_VARARGS | METH_KEYWORDS, NULL},
21837          { (char *)"DC_Ok", (PyCFunction) _wrap_DC_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21838          { (char *)"DC_GetBackgroundMode", (PyCFunction) _wrap_DC_GetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
21839          { (char *)"DC_GetBackground", (PyCFunction) _wrap_DC_GetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21840          { (char *)"DC_GetBrush", (PyCFunction) _wrap_DC_GetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21841          { (char *)"DC_GetFont", (PyCFunction) _wrap_DC_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
21842          { (char *)"DC_GetPen", (PyCFunction) _wrap_DC_GetPen, METH_VARARGS | METH_KEYWORDS, NULL},
21843          { (char *)"DC_GetTextBackground", (PyCFunction) _wrap_DC_GetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21844          { (char *)"DC_GetTextForeground", (PyCFunction) _wrap_DC_GetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
21845          { (char *)"DC_SetTextForeground", (PyCFunction) _wrap_DC_SetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
21846          { (char *)"DC_SetTextBackground", (PyCFunction) _wrap_DC_SetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21847          { (char *)"DC_GetMapMode", (PyCFunction) _wrap_DC_GetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
21848          { (char *)"DC_SetMapMode", (PyCFunction) _wrap_DC_SetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
21849          { (char *)"DC_GetUserScale", (PyCFunction) _wrap_DC_GetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
21850          { (char *)"DC_SetUserScale", (PyCFunction) _wrap_DC_SetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
21851          { (char *)"DC_GetLogicalScale", (PyCFunction) _wrap_DC_GetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
21852          { (char *)"DC_SetLogicalScale", (PyCFunction) _wrap_DC_SetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
21853          { (char *)"DC_GetLogicalOrigin", (PyCFunction) _wrap_DC_GetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21854          { (char *)"DC_GetLogicalOriginTuple", (PyCFunction) _wrap_DC_GetLogicalOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21855          { (char *)"DC_SetLogicalOrigin", (PyCFunction) _wrap_DC_SetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21856          { (char *)"DC_SetLogicalOriginPoint", (PyCFunction) _wrap_DC_SetLogicalOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21857          { (char *)"DC_GetDeviceOrigin", (PyCFunction) _wrap_DC_GetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21858          { (char *)"DC_GetDeviceOriginTuple", (PyCFunction) _wrap_DC_GetDeviceOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21859          { (char *)"DC_SetDeviceOrigin", (PyCFunction) _wrap_DC_SetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21860          { (char *)"DC_SetDeviceOriginPoint", (PyCFunction) _wrap_DC_SetDeviceOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21861          { (char *)"DC_SetAxisOrientation", (PyCFunction) _wrap_DC_SetAxisOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
21862          { (char *)"DC_GetLogicalFunction", (PyCFunction) _wrap_DC_GetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
21863          { (char *)"DC_SetLogicalFunction", (PyCFunction) _wrap_DC_SetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
21864          { (char *)"DC_ComputeScaleAndOrigin", (PyCFunction) _wrap_DC_ComputeScaleAndOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21865          { (char *)"DC_CalcBoundingBox", (PyCFunction) _wrap_DC_CalcBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21866          { (char *)"DC_CalcBoundingBoxPoint", (PyCFunction) _wrap_DC_CalcBoundingBoxPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21867          { (char *)"DC_ResetBoundingBox", (PyCFunction) _wrap_DC_ResetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21868          { (char *)"DC_MinX", (PyCFunction) _wrap_DC_MinX, METH_VARARGS | METH_KEYWORDS, NULL},
21869          { (char *)"DC_MaxX", (PyCFunction) _wrap_DC_MaxX, METH_VARARGS | METH_KEYWORDS, NULL},
21870          { (char *)"DC_MinY", (PyCFunction) _wrap_DC_MinY, METH_VARARGS | METH_KEYWORDS, NULL},
21871          { (char *)"DC_MaxY", (PyCFunction) _wrap_DC_MaxY, METH_VARARGS | METH_KEYWORDS, NULL},
21872          { (char *)"DC_GetBoundingBox", (PyCFunction) _wrap_DC_GetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21873          { (char *)"DC_GetHDC", (PyCFunction) _wrap_DC_GetHDC, METH_VARARGS | METH_KEYWORDS, NULL},
21874          { (char *)"DC__DrawPointList", (PyCFunction) _wrap_DC__DrawPointList, METH_VARARGS | METH_KEYWORDS, NULL},
21875          { (char *)"DC__DrawLineList", (PyCFunction) _wrap_DC__DrawLineList, METH_VARARGS | METH_KEYWORDS, NULL},
21876          { (char *)"DC__DrawRectangleList", (PyCFunction) _wrap_DC__DrawRectangleList, METH_VARARGS | METH_KEYWORDS, NULL},
21877          { (char *)"DC__DrawEllipseList", (PyCFunction) _wrap_DC__DrawEllipseList, METH_VARARGS | METH_KEYWORDS, NULL},
21878          { (char *)"DC__DrawPolygonList", (PyCFunction) _wrap_DC__DrawPolygonList, METH_VARARGS | METH_KEYWORDS, NULL},
21879          { (char *)"DC__DrawTextList", (PyCFunction) _wrap_DC__DrawTextList, METH_VARARGS | METH_KEYWORDS, NULL},
21880          { (char *)"DC_swigregister", DC_swigregister, METH_VARARGS, NULL},
21881          { (char *)"new_MemoryDC", (PyCFunction) _wrap_new_MemoryDC, METH_VARARGS | METH_KEYWORDS, NULL},
21882          { (char *)"new_MemoryDCFromDC", (PyCFunction) _wrap_new_MemoryDCFromDC, METH_VARARGS | METH_KEYWORDS, NULL},
21883          { (char *)"MemoryDC_SelectObject", (PyCFunction) _wrap_MemoryDC_SelectObject, METH_VARARGS | METH_KEYWORDS, NULL},
21884          { (char *)"MemoryDC_swigregister", MemoryDC_swigregister, METH_VARARGS, NULL},
21885          { (char *)"new_BufferedDC", _wrap_new_BufferedDC, METH_VARARGS, NULL},
21886          { (char *)"delete_BufferedDC", (PyCFunction) _wrap_delete_BufferedDC, METH_VARARGS | METH_KEYWORDS, NULL},
21887          { (char *)"BufferedDC_UnMask", (PyCFunction) _wrap_BufferedDC_UnMask, METH_VARARGS | METH_KEYWORDS, NULL},
21888          { (char *)"BufferedDC_swigregister", BufferedDC_swigregister, METH_VARARGS, NULL},
21889          { (char *)"new_BufferedPaintDC", (PyCFunction) _wrap_new_BufferedPaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
21890          { (char *)"BufferedPaintDC_swigregister", BufferedPaintDC_swigregister, METH_VARARGS, NULL},
21891          { (char *)"new_ScreenDC", (PyCFunction) _wrap_new_ScreenDC, METH_VARARGS | METH_KEYWORDS, NULL},
21892          { (char *)"ScreenDC_StartDrawingOnTopWin", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTopWin, METH_VARARGS | METH_KEYWORDS, NULL},
21893          { (char *)"ScreenDC_StartDrawingOnTop", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
21894          { (char *)"ScreenDC_EndDrawingOnTop", (PyCFunction) _wrap_ScreenDC_EndDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
21895          { (char *)"ScreenDC_swigregister", ScreenDC_swigregister, METH_VARARGS, NULL},
21896          { (char *)"new_ClientDC", (PyCFunction) _wrap_new_ClientDC, METH_VARARGS | METH_KEYWORDS, NULL},
21897          { (char *)"ClientDC_swigregister", ClientDC_swigregister, METH_VARARGS, NULL},
21898          { (char *)"new_PaintDC", (PyCFunction) _wrap_new_PaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
21899          { (char *)"PaintDC_swigregister", PaintDC_swigregister, METH_VARARGS, NULL},
21900          { (char *)"new_WindowDC", (PyCFunction) _wrap_new_WindowDC, METH_VARARGS | METH_KEYWORDS, NULL},
21901          { (char *)"WindowDC_swigregister", WindowDC_swigregister, METH_VARARGS, NULL},
21902          { (char *)"new_MirrorDC", (PyCFunction) _wrap_new_MirrorDC, METH_VARARGS | METH_KEYWORDS, NULL},
21903          { (char *)"MirrorDC_swigregister", MirrorDC_swigregister, METH_VARARGS, NULL},
21904          { (char *)"new_PostScriptDC", (PyCFunction) _wrap_new_PostScriptDC, METH_VARARGS | METH_KEYWORDS, NULL},
21905          { (char *)"PostScriptDC_GetPrintData", (PyCFunction) _wrap_PostScriptDC_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
21906          { (char *)"PostScriptDC_SetPrintData", (PyCFunction) _wrap_PostScriptDC_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
21907          { (char *)"PostScriptDC_SetResolution", (PyCFunction) _wrap_PostScriptDC_SetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
21908          { (char *)"PostScriptDC_GetResolution", (PyCFunction) _wrap_PostScriptDC_GetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
21909          { (char *)"PostScriptDC_swigregister", PostScriptDC_swigregister, METH_VARARGS, NULL},
21910          { (char *)"new_MetaFile", (PyCFunction) _wrap_new_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
21911          { (char *)"delete_MetaFile", (PyCFunction) _wrap_delete_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
21912          { (char *)"MetaFile_Ok", (PyCFunction) _wrap_MetaFile_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21913          { (char *)"MetaFile_SetClipboard", (PyCFunction) _wrap_MetaFile_SetClipboard, METH_VARARGS | METH_KEYWORDS, NULL},
21914          { (char *)"MetaFile_GetSize", (PyCFunction) _wrap_MetaFile_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21915          { (char *)"MetaFile_GetWidth", (PyCFunction) _wrap_MetaFile_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21916          { (char *)"MetaFile_GetHeight", (PyCFunction) _wrap_MetaFile_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21917          { (char *)"MetaFile_GetFileName", (PyCFunction) _wrap_MetaFile_GetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
21918          { (char *)"MetaFile_swigregister", MetaFile_swigregister, METH_VARARGS, NULL},
21919          { (char *)"new_MetaFileDC", (PyCFunction) _wrap_new_MetaFileDC, METH_VARARGS | METH_KEYWORDS, NULL},
21920          { (char *)"MetaFileDC_Close", (PyCFunction) _wrap_MetaFileDC_Close, METH_VARARGS | METH_KEYWORDS, NULL},
21921          { (char *)"MetaFileDC_swigregister", MetaFileDC_swigregister, METH_VARARGS, NULL},
21922          { (char *)"new_PrinterDC", (PyCFunction) _wrap_new_PrinterDC, METH_VARARGS | METH_KEYWORDS, NULL},
21923          { (char *)"PrinterDC_swigregister", PrinterDC_swigregister, METH_VARARGS, NULL},
21924          { (char *)"new_ImageList", (PyCFunction) _wrap_new_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
21925          { (char *)"delete_ImageList", (PyCFunction) _wrap_delete_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
21926          { (char *)"ImageList_Add", (PyCFunction) _wrap_ImageList_Add, METH_VARARGS | METH_KEYWORDS, NULL},
21927          { (char *)"ImageList_AddWithColourMask", (PyCFunction) _wrap_ImageList_AddWithColourMask, METH_VARARGS | METH_KEYWORDS, NULL},
21928          { (char *)"ImageList_AddIcon", (PyCFunction) _wrap_ImageList_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21929          { (char *)"ImageList_GetBitmap", (PyCFunction) _wrap_ImageList_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21930          { (char *)"ImageList_GetIcon", (PyCFunction) _wrap_ImageList_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21931          { (char *)"ImageList_Replace", (PyCFunction) _wrap_ImageList_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
21932          { (char *)"ImageList_Draw", (PyCFunction) _wrap_ImageList_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
21933          { (char *)"ImageList_GetImageCount", (PyCFunction) _wrap_ImageList_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
21934          { (char *)"ImageList_Remove", (PyCFunction) _wrap_ImageList_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
21935          { (char *)"ImageList_RemoveAll", (PyCFunction) _wrap_ImageList_RemoveAll, METH_VARARGS | METH_KEYWORDS, NULL},
21936          { (char *)"ImageList_GetSize", (PyCFunction) _wrap_ImageList_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21937          { (char *)"ImageList_swigregister", ImageList_swigregister, METH_VARARGS, NULL},
21938          { (char *)"PenList_AddPen", (PyCFunction) _wrap_PenList_AddPen, METH_VARARGS | METH_KEYWORDS, NULL},
21939          { (char *)"PenList_FindOrCreatePen", (PyCFunction) _wrap_PenList_FindOrCreatePen, METH_VARARGS | METH_KEYWORDS, NULL},
21940          { (char *)"PenList_RemovePen", (PyCFunction) _wrap_PenList_RemovePen, METH_VARARGS | METH_KEYWORDS, NULL},
21941          { (char *)"PenList_GetCount", (PyCFunction) _wrap_PenList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21942          { (char *)"PenList_swigregister", PenList_swigregister, METH_VARARGS, NULL},
21943          { (char *)"BrushList_AddBrush", (PyCFunction) _wrap_BrushList_AddBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21944          { (char *)"BrushList_FindOrCreateBrush", (PyCFunction) _wrap_BrushList_FindOrCreateBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21945          { (char *)"BrushList_RemoveBrush", (PyCFunction) _wrap_BrushList_RemoveBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21946          { (char *)"BrushList_GetCount", (PyCFunction) _wrap_BrushList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21947          { (char *)"BrushList_swigregister", BrushList_swigregister, METH_VARARGS, NULL},
21948          { (char *)"new_ColourDatabase", (PyCFunction) _wrap_new_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
21949          { (char *)"delete_ColourDatabase", (PyCFunction) _wrap_delete_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
21950          { (char *)"ColourDatabase_Find", (PyCFunction) _wrap_ColourDatabase_Find, METH_VARARGS | METH_KEYWORDS, NULL},
21951          { (char *)"ColourDatabase_FindName", (PyCFunction) _wrap_ColourDatabase_FindName, METH_VARARGS | METH_KEYWORDS, NULL},
21952          { (char *)"ColourDatabase_AddColour", (PyCFunction) _wrap_ColourDatabase_AddColour, METH_VARARGS | METH_KEYWORDS, NULL},
21953          { (char *)"ColourDatabase_Append", (PyCFunction) _wrap_ColourDatabase_Append, METH_VARARGS | METH_KEYWORDS, NULL},
21954          { (char *)"ColourDatabase_swigregister", ColourDatabase_swigregister, METH_VARARGS, NULL},
21955          { (char *)"FontList_AddFont", (PyCFunction) _wrap_FontList_AddFont, METH_VARARGS | METH_KEYWORDS, NULL},
21956          { (char *)"FontList_FindOrCreateFont", (PyCFunction) _wrap_FontList_FindOrCreateFont, METH_VARARGS | METH_KEYWORDS, NULL},
21957          { (char *)"FontList_RemoveFont", (PyCFunction) _wrap_FontList_RemoveFont, METH_VARARGS | METH_KEYWORDS, NULL},
21958          { (char *)"FontList_GetCount", (PyCFunction) _wrap_FontList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21959          { (char *)"FontList_swigregister", FontList_swigregister, METH_VARARGS, NULL},
21960          { (char *)"new_Effects", (PyCFunction) _wrap_new_Effects, METH_VARARGS | METH_KEYWORDS, NULL},
21961          { (char *)"Effects_GetHighlightColour", (PyCFunction) _wrap_Effects_GetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
21962          { (char *)"Effects_GetLightShadow", (PyCFunction) _wrap_Effects_GetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21963          { (char *)"Effects_GetFaceColour", (PyCFunction) _wrap_Effects_GetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
21964          { (char *)"Effects_GetMediumShadow", (PyCFunction) _wrap_Effects_GetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21965          { (char *)"Effects_GetDarkShadow", (PyCFunction) _wrap_Effects_GetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21966          { (char *)"Effects_SetHighlightColour", (PyCFunction) _wrap_Effects_SetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
21967          { (char *)"Effects_SetLightShadow", (PyCFunction) _wrap_Effects_SetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21968          { (char *)"Effects_SetFaceColour", (PyCFunction) _wrap_Effects_SetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
21969          { (char *)"Effects_SetMediumShadow", (PyCFunction) _wrap_Effects_SetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21970          { (char *)"Effects_SetDarkShadow", (PyCFunction) _wrap_Effects_SetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21971          { (char *)"Effects_Set", (PyCFunction) _wrap_Effects_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21972          { (char *)"Effects_DrawSunkenEdge", (PyCFunction) _wrap_Effects_DrawSunkenEdge, METH_VARARGS | METH_KEYWORDS, NULL},
21973          { (char *)"Effects_TileBitmap", (PyCFunction) _wrap_Effects_TileBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21974          { (char *)"Effects_swigregister", Effects_swigregister, METH_VARARGS, NULL},
21975          { NULL, NULL, 0, NULL }
21976 };
21977
21978
21979 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
21980
21981 static void *_p_wxBufferedDCTo_p_wxMemoryDC(void *x) {
21982     return (void *)((wxMemoryDC *)  ((wxBufferedDC *) x));
21983 }
21984 static void *_p_wxBufferedPaintDCTo_p_wxMemoryDC(void *x) {
21985     return (void *)((wxMemoryDC *) (wxBufferedDC *) ((wxBufferedPaintDC *) x));
21986 }
21987 static void *_p_wxIconTo_p_wxGDIObject(void *x) {
21988     return (void *)((wxGDIObject *)  ((wxIcon *) x));
21989 }
21990 static void *_p_wxPaletteTo_p_wxGDIObject(void *x) {
21991     return (void *)((wxGDIObject *)  ((wxPalette *) x));
21992 }
21993 static void *_p_wxPenTo_p_wxGDIObject(void *x) {
21994     return (void *)((wxGDIObject *)  ((wxPen *) x));
21995 }
21996 static void *_p_wxFontTo_p_wxGDIObject(void *x) {
21997     return (void *)((wxGDIObject *)  ((wxFont *) x));
21998 }
21999 static void *_p_wxCursorTo_p_wxGDIObject(void *x) {
22000     return (void *)((wxGDIObject *)  ((wxCursor *) x));
22001 }
22002 static void *_p_wxBitmapTo_p_wxGDIObject(void *x) {
22003     return (void *)((wxGDIObject *)  ((wxBitmap *) x));
22004 }
22005 static void *_p_wxRegionTo_p_wxGDIObject(void *x) {
22006     return (void *)((wxGDIObject *)  ((wxRegion *) x));
22007 }
22008 static void *_p_wxBrushTo_p_wxGDIObject(void *x) {
22009     return (void *)((wxGDIObject *)  ((wxBrush *) x));
22010 }
22011 static void *_p_wxBufferedDCTo_p_wxDC(void *x) {
22012     return (void *)((wxDC *) (wxMemoryDC *) ((wxBufferedDC *) x));
22013 }
22014 static void *_p_wxScreenDCTo_p_wxDC(void *x) {
22015     return (void *)((wxDC *)  ((wxScreenDC *) x));
22016 }
22017 static void *_p_wxMirrorDCTo_p_wxDC(void *x) {
22018     return (void *)((wxDC *)  ((wxMirrorDC *) x));
22019 }
22020 static void *_p_wxMemoryDCTo_p_wxDC(void *x) {
22021     return (void *)((wxDC *)  ((wxMemoryDC *) x));
22022 }
22023 static void *_p_wxWindowDCTo_p_wxDC(void *x) {
22024     return (void *)((wxDC *)  ((wxWindowDC *) x));
22025 }
22026 static void *_p_wxMetaFileDCTo_p_wxDC(void *x) {
22027     return (void *)((wxDC *)  ((wxMetaFileDC *) x));
22028 }
22029 static void *_p_wxBufferedPaintDCTo_p_wxDC(void *x) {
22030     return (void *)((wxDC *) (wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
22031 }
22032 static void *_p_wxClientDCTo_p_wxDC(void *x) {
22033     return (void *)((wxDC *)  ((wxClientDC *) x));
22034 }
22035 static void *_p_wxPaintDCTo_p_wxDC(void *x) {
22036     return (void *)((wxDC *)  ((wxPaintDC *) x));
22037 }
22038 static void *_p_wxPostScriptDCTo_p_wxDC(void *x) {
22039     return (void *)((wxDC *)  ((wxPostScriptDC *) x));
22040 }
22041 static void *_p_wxPrinterDCTo_p_wxDC(void *x) {
22042     return (void *)((wxDC *)  ((wxPrinterDC *) x));
22043 }
22044 static void *_p_wxBufferedPaintDCTo_p_wxBufferedDC(void *x) {
22045     return (void *)((wxBufferedDC *)  ((wxBufferedPaintDC *) x));
22046 }
22047 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
22048     return (void *)((wxObject *)  ((wxLayoutConstraints *) x));
22049 }
22050 static void *_p_wxPenTo_p_wxObject(void *x) {
22051     return (void *)((wxObject *) (wxGDIObject *) ((wxPen *) x));
22052 }
22053 static void *_p_wxRegionIteratorTo_p_wxObject(void *x) {
22054     return (void *)((wxObject *)  ((wxRegionIterator *) x));
22055 }
22056 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
22057     return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
22058 }
22059 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
22060     return (void *)((wxObject *)  ((wxSizerItem *) x));
22061 }
22062 static void *_p_wxColourDatabaseTo_p_wxObject(void *x) {
22063     return (void *)((wxObject *)  ((wxColourDatabase *) x));
22064 }
22065 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
22066     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
22067 }
22068 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
22069     return (void *)((wxObject *)  ((wxIndividualLayoutConstraint *) x));
22070 }
22071 static void *_p_wxIconTo_p_wxObject(void *x) {
22072     return (void *)((wxObject *) (wxGDIObject *) ((wxIcon *) x));
22073 }
22074 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
22075     return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
22076 }
22077 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
22078     return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
22079 }
22080 static void *_p_wxSizerTo_p_wxObject(void *x) {
22081     return (void *)((wxObject *)  ((wxSizer *) x));
22082 }
22083 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
22084     return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
22085 }
22086 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
22087     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
22088 }
22089 static void *_p_wxPenListTo_p_wxObject(void *x) {
22090     return (void *)((wxObject *)  ((wxPenList *) x));
22091 }
22092 static void *_p_wxEventTo_p_wxObject(void *x) {
22093     return (void *)((wxObject *)  ((wxEvent *) x));
22094 }
22095 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
22096     return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
22097 }
22098 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
22099     return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
22100 }
22101 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
22102     return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
22103 }
22104 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
22105     return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
22106 }
22107 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
22108     return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
22109 }
22110 static void *_p_wxDCTo_p_wxObject(void *x) {
22111     return (void *)((wxObject *)  ((wxDC *) x));
22112 }
22113 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
22114     return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
22115 }
22116 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
22117     return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
22118 }
22119 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
22120     return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
22121 }
22122 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
22123     return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
22124 }
22125 static void *_p_wxControlTo_p_wxObject(void *x) {
22126     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
22127 }
22128 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
22129     return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
22130 }
22131 static void *_p_wxClientDCTo_p_wxObject(void *x) {
22132     return (void *)((wxObject *) (wxDC *) ((wxClientDC *) x));
22133 }
22134 static void *_p_wxFSFileTo_p_wxObject(void *x) {
22135     return (void *)((wxObject *)  ((wxFSFile *) x));
22136 }
22137 static void *_p_wxMemoryDCTo_p_wxObject(void *x) {
22138     return (void *)((wxObject *) (wxDC *) ((wxMemoryDC *) x));
22139 }
22140 static void *_p_wxRegionTo_p_wxObject(void *x) {
22141     return (void *)((wxObject *) (wxGDIObject *) ((wxRegion *) x));
22142 }
22143 static void *_p_wxPySizerTo_p_wxObject(void *x) {
22144     return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
22145 }
22146 static void *_p_wxWindowDCTo_p_wxObject(void *x) {
22147     return (void *)((wxObject *) (wxDC *) ((wxWindowDC *) x));
22148 }
22149 static void *_p_wxGDIObjectTo_p_wxObject(void *x) {
22150     return (void *)((wxObject *)  ((wxGDIObject *) x));
22151 }
22152 static void *_p_wxEffectsTo_p_wxObject(void *x) {
22153     return (void *)((wxObject *)  ((wxEffects *) x));
22154 }
22155 static void *_p_wxPyEventTo_p_wxObject(void *x) {
22156     return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
22157 }
22158 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
22159     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
22160 }
22161 static void *_p_wxPostScriptDCTo_p_wxObject(void *x) {
22162     return (void *)((wxObject *) (wxDC *) ((wxPostScriptDC *) x));
22163 }
22164 static void *_p_wxShowEventTo_p_wxObject(void *x) {
22165     return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
22166 }
22167 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
22168     return (void *)((wxObject *)  ((wxMenuItem *) x));
22169 }
22170 static void *_p_wxDateEventTo_p_wxObject(void *x) {
22171     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
22172 }
22173 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
22174     return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
22175 }
22176 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
22177     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
22178 }
22179 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
22180     return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
22181 }
22182 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
22183     return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
22184 }
22185 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
22186     return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
22187 }
22188 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
22189     return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
22190 }
22191 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
22192     return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
22193 }
22194 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
22195     return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
22196 }
22197 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
22198     return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
22199 }
22200 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
22201     return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
22202 }
22203 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
22204     return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
22205 }
22206 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
22207     return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
22208 }
22209 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
22210     return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
22211 }
22212 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
22213     return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
22214 }
22215 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
22216     return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
22217 }
22218 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
22219     return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
22220 }
22221 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
22222     return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
22223 }
22224 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
22225     return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
22226 }
22227 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
22228     return (void *)((wxObject *)  ((wxImageHandler *) x));
22229 }
22230 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
22231     return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
22232 }
22233 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
22234     return (void *)((wxObject *)  ((wxEvtHandler *) x));
22235 }
22236 static void *_p_wxBufferedPaintDCTo_p_wxObject(void *x) {
22237     return (void *)((wxObject *) (wxDC *)(wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
22238 }
22239 static void *_p_wxPaintDCTo_p_wxObject(void *x) {
22240     return (void *)((wxObject *) (wxDC *) ((wxPaintDC *) x));
22241 }
22242 static void *_p_wxPrinterDCTo_p_wxObject(void *x) {
22243     return (void *)((wxObject *) (wxDC *) ((wxPrinterDC *) x));
22244 }
22245 static void *_p_wxScreenDCTo_p_wxObject(void *x) {
22246     return (void *)((wxObject *) (wxDC *) ((wxScreenDC *) x));
22247 }
22248 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
22249     return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
22250 }
22251 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
22252     return (void *)((wxObject *)  ((wxAcceleratorTable *) x));
22253 }
22254 static void *_p_wxImageTo_p_wxObject(void *x) {
22255     return (void *)((wxObject *)  ((wxImage *) x));
22256 }
22257 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
22258     return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
22259 }
22260 static void *_p_wxPaletteTo_p_wxObject(void *x) {
22261     return (void *)((wxObject *) (wxGDIObject *) ((wxPalette *) x));
22262 }
22263 static void *_p_wxBufferedDCTo_p_wxObject(void *x) {
22264     return (void *)((wxObject *) (wxDC *)(wxMemoryDC *) ((wxBufferedDC *) x));
22265 }
22266 static void *_p_wxImageListTo_p_wxObject(void *x) {
22267     return (void *)((wxObject *)  ((wxImageList *) x));
22268 }
22269 static void *_p_wxCursorTo_p_wxObject(void *x) {
22270     return (void *)((wxObject *) (wxGDIObject *) ((wxCursor *) x));
22271 }
22272 static void *_p_wxEncodingConverterTo_p_wxObject(void *x) {
22273     return (void *)((wxObject *)  ((wxEncodingConverter *) x));
22274 }
22275 static void *_p_wxMirrorDCTo_p_wxObject(void *x) {
22276     return (void *)((wxObject *) (wxDC *) ((wxMirrorDC *) x));
22277 }
22278 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
22279     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
22280 }
22281 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
22282     return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
22283 }
22284 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
22285     return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
22286 }
22287 static void *_p_wxWindowTo_p_wxObject(void *x) {
22288     return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
22289 }
22290 static void *_p_wxMenuTo_p_wxObject(void *x) {
22291     return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
22292 }
22293 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
22294     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
22295 }
22296 static void *_p_wxMetaFileDCTo_p_wxObject(void *x) {
22297     return (void *)((wxObject *) (wxDC *) ((wxMetaFileDC *) x));
22298 }
22299 static void *_p_wxBrushListTo_p_wxObject(void *x) {
22300     return (void *)((wxObject *)  ((wxBrushList *) x));
22301 }
22302 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
22303     return (void *)((wxObject *)  ((wxFileSystem *) x));
22304 }
22305 static void *_p_wxBitmapTo_p_wxObject(void *x) {
22306     return (void *)((wxObject *) (wxGDIObject *) ((wxBitmap *) x));
22307 }
22308 static void *_p_wxMaskTo_p_wxObject(void *x) {
22309     return (void *)((wxObject *)  ((wxMask *) x));
22310 }
22311 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
22312     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
22313 }
22314 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
22315     return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
22316 }
22317 static void *_p_wxPyAppTo_p_wxObject(void *x) {
22318     return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
22319 }
22320 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
22321     return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
22322 }
22323 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
22324     return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
22325 }
22326 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
22327     return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
22328 }
22329 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
22330     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
22331 }
22332 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
22333     return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
22334 }
22335 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
22336     return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
22337 }
22338 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
22339     return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
22340 }
22341 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
22342     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
22343 }
22344 static void *_p_wxFontTo_p_wxObject(void *x) {
22345     return (void *)((wxObject *) (wxGDIObject *) ((wxFont *) x));
22346 }
22347 static void *_p_wxBrushTo_p_wxObject(void *x) {
22348     return (void *)((wxObject *) (wxGDIObject *) ((wxBrush *) x));
22349 }
22350 static void *_p_wxMetaFileTo_p_wxObject(void *x) {
22351     return (void *)((wxObject *)  ((wxMetaFile *) x));
22352 }
22353 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
22354     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
22355 }
22356 static void *_p_wxColourTo_p_wxObject(void *x) {
22357     return (void *)((wxObject *)  ((wxColour *) x));
22358 }
22359 static void *_p_wxFontListTo_p_wxObject(void *x) {
22360     return (void *)((wxObject *)  ((wxFontList *) x));
22361 }
22362 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
22363     return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
22364 }
22365 static void *_p_wxValidatorTo_p_wxObject(void *x) {
22366     return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
22367 }
22368 static void *_p_wxControlTo_p_wxWindow(void *x) {
22369     return (void *)((wxWindow *)  ((wxControl *) x));
22370 }
22371 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
22372     return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
22373 }
22374 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
22375     return (void *)((wxWindow *)  ((wxMenuBar *) x));
22376 }
22377 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}};
22378 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}};
22379 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}};
22380 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}};
22381 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}};
22382 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}};
22383 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}};
22384 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}};
22385 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}};
22386 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}};
22387 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}};
22388 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}};
22389 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}};
22390 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}};
22391 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}};
22392 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}};
22393 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}};
22394 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}};
22395 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}};
22396 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}};
22397 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}};
22398 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}};
22399 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}};
22400 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}};
22401 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}};
22402 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}};
22403 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}};
22404 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}};
22405 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}};
22406 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}};
22407 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}};
22408 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}};
22409 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}};
22410 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}};
22411 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}};
22412 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}};
22413 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}};
22414 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}};
22415 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}};
22416 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}};
22417 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}};
22418 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}};
22419 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}};
22420 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}};
22421 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}};
22422 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}};
22423 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}};
22424 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}};
22425 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}};
22426 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}};
22427 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}};
22428 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}};
22429 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}};
22430 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}};
22431 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}};
22432 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}};
22433 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}};
22434 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}};
22435 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}};
22436 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}};
22437 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}};
22438 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}};
22439
22440 static swig_type_info *swig_types_initial[] = {
22441 _swigt__p_wxPostScriptDC,
22442 _swigt__p_wxBrush,
22443 _swigt__p_wxColour,
22444 _swigt__p_wxDC,
22445 _swigt__p_wxMirrorDC,
22446 _swigt__p_form_ops_t,
22447 _swigt__p_wxDuplexMode,
22448 _swigt__p_wxPyFontEnumerator,
22449 _swigt__p_char,
22450 _swigt__p_wxIconLocation,
22451 _swigt__p_wxImage,
22452 _swigt__p_wxMetaFileDC,
22453 _swigt__p_wxMask,
22454 _swigt__p_wxSize,
22455 _swigt__p_wxFont,
22456 _swigt__p_wxWindow,
22457 _swigt__p_double,
22458 _swigt__p_wxMemoryDC,
22459 _swigt__p_wxFontMapper,
22460 _swigt__p_wxEffects,
22461 _swigt__p_wxNativeEncodingInfo,
22462 _swigt__p_wxPalette,
22463 _swigt__p_wxBitmap,
22464 _swigt__p_wxObject,
22465 _swigt__p_wxRegionIterator,
22466 _swigt__p_wxRect,
22467 _swigt__p_wxPaperSize,
22468 _swigt__p_wxString,
22469 _swigt__unsigned_int,
22470 _swigt__p_unsigned_int,
22471 _swigt__p_wxPrinterDC,
22472 _swigt__p_wxIconBundle,
22473 _swigt__p_wxPoint,
22474 _swigt__p_wxDash,
22475 _swigt__p_wxScreenDC,
22476 _swigt__p_wxCursor,
22477 _swigt__p_wxClientDC,
22478 _swigt__p_wxBufferedDC,
22479 _swigt__p_wxImageList,
22480 _swigt__p_unsigned_char,
22481 _swigt__p_wxGDIObject,
22482 _swigt__p_wxIcon,
22483 _swigt__p_wxLocale,
22484 _swigt__ptrdiff_t,
22485 _swigt__std__ptrdiff_t,
22486 _swigt__p_wxRegion,
22487 _swigt__p_wxConfigBase,
22488 _swigt__p_wxLanguageInfo,
22489 _swigt__p_wxWindowDC,
22490 _swigt__p_wxPrintData,
22491 _swigt__p_wxBrushList,
22492 _swigt__p_wxFontList,
22493 _swigt__p_wxPen,
22494 _swigt__p_wxBufferedPaintDC,
22495 _swigt__p_wxPaintDC,
22496 _swigt__p_wxPenList,
22497 _swigt__p_int,
22498 _swigt__p_wxMetaFile,
22499 _swigt__p_unsigned_long,
22500 _swigt__p_wxNativeFontInfo,
22501 _swigt__p_wxEncodingConverter,
22502 _swigt__p_wxColourDatabase,
22503 0
22504 };
22505
22506
22507 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
22508
22509 static swig_const_info swig_const_table[] = {
22510 {0, 0, 0, 0.0, 0, 0}};
22511
22512 #ifdef __cplusplus
22513 }
22514 #endif
22515
22516
22517 #ifdef __cplusplus
22518 extern "C" {
22519 #endif
22520
22521     /* Python-specific SWIG API */
22522 #define SWIG_newvarlink()                             SWIG_Python_newvarlink()
22523 #define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
22524 #define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
22525
22526     /* -----------------------------------------------------------------------------
22527      * global variable support code.
22528      * ----------------------------------------------------------------------------- */
22529
22530     typedef struct swig_globalvar {
22531         char       *name;                  /* Name of global variable */
22532         PyObject *(*get_attr)();           /* Return the current value */
22533         int       (*set_attr)(PyObject *); /* Set the value */
22534         struct swig_globalvar *next;
22535     } swig_globalvar;
22536
22537     typedef struct swig_varlinkobject {
22538         PyObject_HEAD
22539         swig_globalvar *vars;
22540     } swig_varlinkobject;
22541
22542     static PyObject *
22543     swig_varlink_repr(swig_varlinkobject *v) {
22544         v = v;
22545         return PyString_FromString("<Swig global variables>");
22546     }
22547
22548     static int
22549     swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
22550         swig_globalvar  *var;
22551         flags = flags;
22552         fprintf(fp,"Swig global variables { ");
22553         for (var = v->vars; var; var=var->next) {
22554             fprintf(fp,"%s", var->name);
22555             if (var->next) fprintf(fp,", ");
22556         }
22557         fprintf(fp," }\n");
22558         return 0;
22559     }
22560
22561     static PyObject *
22562     swig_varlink_getattr(swig_varlinkobject *v, char *n) {
22563         swig_globalvar *var = v->vars;
22564         while (var) {
22565             if (strcmp(var->name,n) == 0) {
22566                 return (*var->get_attr)();
22567             }
22568             var = var->next;
22569         }
22570         PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22571         return NULL;
22572     }
22573
22574     static int
22575     swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
22576         swig_globalvar *var = v->vars;
22577         while (var) {
22578             if (strcmp(var->name,n) == 0) {
22579                 return (*var->set_attr)(p);
22580             }
22581             var = var->next;
22582         }
22583         PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22584         return 1;
22585     }
22586
22587     static PyTypeObject varlinktype = {
22588         PyObject_HEAD_INIT(0)
22589         0,                                  /* Number of items in variable part (ob_size) */
22590         (char *)"swigvarlink",              /* Type name (tp_name) */
22591         sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
22592         0,                                  /* Itemsize (tp_itemsize) */
22593         0,                                  /* Deallocator (tp_dealloc) */
22594         (printfunc) swig_varlink_print,     /* Print (tp_print) */
22595         (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
22596         (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
22597         0,                                  /* tp_compare */
22598         (reprfunc) swig_varlink_repr,       /* tp_repr */
22599         0,                                  /* tp_as_number */
22600         0,                                  /* tp_as_sequence */
22601         0,                                  /* tp_as_mapping */
22602         0,                                  /* tp_hash */
22603         0,                                  /* tp_call */
22604         0,                                  /* tp_str */
22605         0,                                  /* tp_getattro */
22606         0,                                  /* tp_setattro */
22607         0,                                  /* tp_as_buffer */
22608         0,                                  /* tp_flags */
22609         0,                                  /* tp_doc */
22610 #if PY_VERSION_HEX >= 0x02000000
22611         0,                                  /* tp_traverse */
22612         0,                                  /* tp_clear */
22613 #endif
22614 #if PY_VERSION_HEX >= 0x02010000
22615         0,                                  /* tp_richcompare */
22616         0,                                  /* tp_weaklistoffset */
22617 #endif
22618 #if PY_VERSION_HEX >= 0x02020000
22619         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
22620 #endif
22621 #if PY_VERSION_HEX >= 0x02030000
22622         0,                                  /* tp_del */
22623 #endif
22624 #ifdef COUNT_ALLOCS
22625         0,0,0,0                             /* tp_alloc -> tp_next */
22626 #endif
22627     };
22628
22629     /* Create a variable linking object for use later */
22630     static PyObject *
22631     SWIG_Python_newvarlink(void) {
22632         swig_varlinkobject *result = 0;
22633         result = PyMem_NEW(swig_varlinkobject,1);
22634         varlinktype.ob_type = &PyType_Type;    /* Patch varlinktype into a PyType */
22635         result->ob_type = &varlinktype;
22636         result->vars = 0;
22637         result->ob_refcnt = 0;
22638         Py_XINCREF((PyObject *) result);
22639         return ((PyObject*) result);
22640     }
22641
22642     static void
22643     SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
22644         swig_varlinkobject *v;
22645         swig_globalvar *gv;
22646         v= (swig_varlinkobject *) p;
22647         gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
22648         gv->name = (char *) malloc(strlen(name)+1);
22649         strcpy(gv->name,name);
22650         gv->get_attr = get_attr;
22651         gv->set_attr = set_attr;
22652         gv->next = v->vars;
22653         v->vars = gv;
22654     }
22655
22656     /* -----------------------------------------------------------------------------
22657      * constants/methods manipulation
22658      * ----------------------------------------------------------------------------- */
22659
22660     /* Install Constants */
22661     static void
22662     SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
22663         PyObject *obj = 0;
22664         size_t i;
22665         for (i = 0; constants[i].type; i++) {
22666             switch(constants[i].type) {
22667                 case SWIG_PY_INT:
22668                 obj = PyInt_FromLong(constants[i].lvalue);
22669                 break;
22670                 case SWIG_PY_FLOAT:
22671                 obj = PyFloat_FromDouble(constants[i].dvalue);
22672                 break;
22673                 case SWIG_PY_STRING:
22674                 if (constants[i].pvalue) {
22675                     obj = PyString_FromString((char *) constants[i].pvalue);
22676                 } else {
22677                     Py_INCREF(Py_None);
22678                     obj = Py_None;
22679                 }
22680                 break;
22681                 case SWIG_PY_POINTER:
22682                 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
22683                 break;
22684                 case SWIG_PY_BINARY:
22685                 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
22686                 break;
22687                 default:
22688                 obj = 0;
22689                 break;
22690             }
22691             if (obj) {
22692                 PyDict_SetItemString(d,constants[i].name,obj);
22693                 Py_DECREF(obj);
22694             }
22695         }
22696     }
22697
22698     /* -----------------------------------------------------------------------------*/
22699     /* Fix SwigMethods to carry the callback ptrs when needed */
22700     /* -----------------------------------------------------------------------------*/
22701
22702     static void
22703     SWIG_Python_FixMethods(PyMethodDef *methods,
22704     swig_const_info *const_table,
22705     swig_type_info **types,
22706     swig_type_info **types_initial) {
22707         size_t i;
22708         for (i = 0; methods[i].ml_name; ++i) {
22709             char *c = methods[i].ml_doc;
22710             if (c && (c = strstr(c, "swig_ptr: "))) {
22711                 int j;
22712                 swig_const_info *ci = 0;
22713                 char *name = c + 10;
22714                 for (j = 0; const_table[j].type; j++) {
22715                     if (strncmp(const_table[j].name, name,
22716                     strlen(const_table[j].name)) == 0) {
22717                         ci = &(const_table[j]);
22718                         break;
22719                     }
22720                 }
22721                 if (ci) {
22722                     size_t shift = (ci->ptype) - types;
22723                     swig_type_info *ty = types_initial[shift];
22724                     size_t ldoc = (c - methods[i].ml_doc);
22725                     size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
22726                     char *ndoc = (char*)malloc(ldoc + lptr + 10);
22727                     char *buff = ndoc;
22728                     void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
22729                     strncpy(buff, methods[i].ml_doc, ldoc);
22730                     buff += ldoc;
22731                     strncpy(buff, "swig_ptr: ", 10);
22732                     buff += 10;
22733                     SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
22734                     methods[i].ml_doc = ndoc;
22735                 }
22736             }
22737         }
22738     }
22739
22740     /* -----------------------------------------------------------------------------*
22741      *  Initialize type list
22742      * -----------------------------------------------------------------------------*/
22743
22744 #if PY_MAJOR_VERSION < 2
22745     /* PyModule_AddObject function was introduced in Python 2.0.  The following function
22746     is copied out of Python/modsupport.c in python version 2.3.4 */
22747     static int
22748     PyModule_AddObject(PyObject *m, char *name, PyObject *o)
22749     {
22750         PyObject *dict;
22751         if (!PyModule_Check(m)) {
22752             PyErr_SetString(PyExc_TypeError,
22753             "PyModule_AddObject() needs module as first arg");
22754             return -1;
22755         }
22756         if (!o) {
22757             PyErr_SetString(PyExc_TypeError,
22758             "PyModule_AddObject() needs non-NULL value");
22759             return -1;
22760         }
22761
22762         dict = PyModule_GetDict(m);
22763         if (dict == NULL) {
22764             /* Internal error -- modules must have a dict! */
22765             PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
22766             PyModule_GetName(m));
22767             return -1;
22768         }
22769         if (PyDict_SetItemString(dict, name, o))
22770         return -1;
22771         Py_DECREF(o);
22772         return 0;
22773     }
22774 #endif
22775
22776     static swig_type_info **
22777     SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
22778         static PyMethodDef swig_empty_runtime_method_table[] = {
22779             {
22780                 NULL, NULL, 0, NULL
22781             }
22782         };/* Sentinel */
22783
22784         PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
22785         swig_empty_runtime_method_table);
22786         PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
22787         if (pointer && module) {
22788             PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
22789         }
22790         return type_list_handle;
22791     }
22792
22793     static swig_type_info **
22794     SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
22795         swig_type_info **type_pointer;
22796
22797         /* first check if module already created */
22798         type_pointer = SWIG_Python_GetTypeListHandle();
22799         if (type_pointer) {
22800             return type_pointer;
22801         } else {
22802             /* create a new module and variable */
22803             return SWIG_Python_SetTypeListHandle(type_list_handle);
22804         }
22805     }
22806
22807 #ifdef __cplusplus
22808 }
22809 #endif
22810
22811 /* -----------------------------------------------------------------------------*
22812  *  Partial Init method
22813  * -----------------------------------------------------------------------------*/
22814
22815 #ifdef SWIG_LINK_RUNTIME
22816 #ifdef __cplusplus
22817 extern "C"
22818 #endif
22819 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
22820 #endif
22821
22822 #ifdef __cplusplus
22823 extern "C"
22824 #endif
22825 SWIGEXPORT(void) SWIG_init(void) {
22826     static PyObject *SWIG_globals = 0;
22827     static int       typeinit = 0;
22828     PyObject *m, *d;
22829     int       i;
22830     if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
22831
22832     /* Fix SwigMethods to carry the callback ptrs when needed */
22833     SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
22834
22835     m = Py_InitModule((char *) SWIG_name, SwigMethods);
22836     d = PyModule_GetDict(m);
22837
22838     if (!typeinit) {
22839 #ifdef SWIG_LINK_RUNTIME
22840         swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
22841 #else
22842 #  ifndef SWIG_STATIC_RUNTIME
22843         swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
22844 #  endif
22845 #endif
22846         for (i = 0; swig_types_initial[i]; i++) {
22847             swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
22848         }
22849         typeinit = 1;
22850     }
22851     SWIG_InstallConstants(d,swig_const_table);
22852
22853     {
22854         PyDict_SetItemString(d,"OutRegion", SWIG_From_int((int)(wxOutRegion)));
22855     }
22856     {
22857         PyDict_SetItemString(d,"PartRegion", SWIG_From_int((int)(wxPartRegion)));
22858     }
22859     {
22860         PyDict_SetItemString(d,"InRegion", SWIG_From_int((int)(wxInRegion)));
22861     }
22862     {
22863         PyDict_SetItemString(d,"FONTFAMILY_DEFAULT", SWIG_From_int((int)(wxFONTFAMILY_DEFAULT)));
22864     }
22865     {
22866         PyDict_SetItemString(d,"FONTFAMILY_DECORATIVE", SWIG_From_int((int)(wxFONTFAMILY_DECORATIVE)));
22867     }
22868     {
22869         PyDict_SetItemString(d,"FONTFAMILY_ROMAN", SWIG_From_int((int)(wxFONTFAMILY_ROMAN)));
22870     }
22871     {
22872         PyDict_SetItemString(d,"FONTFAMILY_SCRIPT", SWIG_From_int((int)(wxFONTFAMILY_SCRIPT)));
22873     }
22874     {
22875         PyDict_SetItemString(d,"FONTFAMILY_SWISS", SWIG_From_int((int)(wxFONTFAMILY_SWISS)));
22876     }
22877     {
22878         PyDict_SetItemString(d,"FONTFAMILY_MODERN", SWIG_From_int((int)(wxFONTFAMILY_MODERN)));
22879     }
22880     {
22881         PyDict_SetItemString(d,"FONTFAMILY_TELETYPE", SWIG_From_int((int)(wxFONTFAMILY_TELETYPE)));
22882     }
22883     {
22884         PyDict_SetItemString(d,"FONTFAMILY_MAX", SWIG_From_int((int)(wxFONTFAMILY_MAX)));
22885     }
22886     {
22887         PyDict_SetItemString(d,"FONTFAMILY_UNKNOWN", SWIG_From_int((int)(wxFONTFAMILY_UNKNOWN)));
22888     }
22889     {
22890         PyDict_SetItemString(d,"FONTSTYLE_NORMAL", SWIG_From_int((int)(wxFONTSTYLE_NORMAL)));
22891     }
22892     {
22893         PyDict_SetItemString(d,"FONTSTYLE_ITALIC", SWIG_From_int((int)(wxFONTSTYLE_ITALIC)));
22894     }
22895     {
22896         PyDict_SetItemString(d,"FONTSTYLE_SLANT", SWIG_From_int((int)(wxFONTSTYLE_SLANT)));
22897     }
22898     {
22899         PyDict_SetItemString(d,"FONTSTYLE_MAX", SWIG_From_int((int)(wxFONTSTYLE_MAX)));
22900     }
22901     {
22902         PyDict_SetItemString(d,"FONTWEIGHT_NORMAL", SWIG_From_int((int)(wxFONTWEIGHT_NORMAL)));
22903     }
22904     {
22905         PyDict_SetItemString(d,"FONTWEIGHT_LIGHT", SWIG_From_int((int)(wxFONTWEIGHT_LIGHT)));
22906     }
22907     {
22908         PyDict_SetItemString(d,"FONTWEIGHT_BOLD", SWIG_From_int((int)(wxFONTWEIGHT_BOLD)));
22909     }
22910     {
22911         PyDict_SetItemString(d,"FONTWEIGHT_MAX", SWIG_From_int((int)(wxFONTWEIGHT_MAX)));
22912     }
22913     {
22914         PyDict_SetItemString(d,"FONTFLAG_DEFAULT", SWIG_From_int((int)(wxFONTFLAG_DEFAULT)));
22915     }
22916     {
22917         PyDict_SetItemString(d,"FONTFLAG_ITALIC", SWIG_From_int((int)(wxFONTFLAG_ITALIC)));
22918     }
22919     {
22920         PyDict_SetItemString(d,"FONTFLAG_SLANT", SWIG_From_int((int)(wxFONTFLAG_SLANT)));
22921     }
22922     {
22923         PyDict_SetItemString(d,"FONTFLAG_LIGHT", SWIG_From_int((int)(wxFONTFLAG_LIGHT)));
22924     }
22925     {
22926         PyDict_SetItemString(d,"FONTFLAG_BOLD", SWIG_From_int((int)(wxFONTFLAG_BOLD)));
22927     }
22928     {
22929         PyDict_SetItemString(d,"FONTFLAG_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_ANTIALIASED)));
22930     }
22931     {
22932         PyDict_SetItemString(d,"FONTFLAG_NOT_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_NOT_ANTIALIASED)));
22933     }
22934     {
22935         PyDict_SetItemString(d,"FONTFLAG_UNDERLINED", SWIG_From_int((int)(wxFONTFLAG_UNDERLINED)));
22936     }
22937     {
22938         PyDict_SetItemString(d,"FONTFLAG_STRIKETHROUGH", SWIG_From_int((int)(wxFONTFLAG_STRIKETHROUGH)));
22939     }
22940     {
22941         PyDict_SetItemString(d,"FONTFLAG_MASK", SWIG_From_int((int)(wxFONTFLAG_MASK)));
22942     }
22943     {
22944         PyDict_SetItemString(d,"FONTENCODING_SYSTEM", SWIG_From_int((int)(wxFONTENCODING_SYSTEM)));
22945     }
22946     {
22947         PyDict_SetItemString(d,"FONTENCODING_DEFAULT", SWIG_From_int((int)(wxFONTENCODING_DEFAULT)));
22948     }
22949     {
22950         PyDict_SetItemString(d,"FONTENCODING_ISO8859_1", SWIG_From_int((int)(wxFONTENCODING_ISO8859_1)));
22951     }
22952     {
22953         PyDict_SetItemString(d,"FONTENCODING_ISO8859_2", SWIG_From_int((int)(wxFONTENCODING_ISO8859_2)));
22954     }
22955     {
22956         PyDict_SetItemString(d,"FONTENCODING_ISO8859_3", SWIG_From_int((int)(wxFONTENCODING_ISO8859_3)));
22957     }
22958     {
22959         PyDict_SetItemString(d,"FONTENCODING_ISO8859_4", SWIG_From_int((int)(wxFONTENCODING_ISO8859_4)));
22960     }
22961     {
22962         PyDict_SetItemString(d,"FONTENCODING_ISO8859_5", SWIG_From_int((int)(wxFONTENCODING_ISO8859_5)));
22963     }
22964     {
22965         PyDict_SetItemString(d,"FONTENCODING_ISO8859_6", SWIG_From_int((int)(wxFONTENCODING_ISO8859_6)));
22966     }
22967     {
22968         PyDict_SetItemString(d,"FONTENCODING_ISO8859_7", SWIG_From_int((int)(wxFONTENCODING_ISO8859_7)));
22969     }
22970     {
22971         PyDict_SetItemString(d,"FONTENCODING_ISO8859_8", SWIG_From_int((int)(wxFONTENCODING_ISO8859_8)));
22972     }
22973     {
22974         PyDict_SetItemString(d,"FONTENCODING_ISO8859_9", SWIG_From_int((int)(wxFONTENCODING_ISO8859_9)));
22975     }
22976     {
22977         PyDict_SetItemString(d,"FONTENCODING_ISO8859_10", SWIG_From_int((int)(wxFONTENCODING_ISO8859_10)));
22978     }
22979     {
22980         PyDict_SetItemString(d,"FONTENCODING_ISO8859_11", SWIG_From_int((int)(wxFONTENCODING_ISO8859_11)));
22981     }
22982     {
22983         PyDict_SetItemString(d,"FONTENCODING_ISO8859_12", SWIG_From_int((int)(wxFONTENCODING_ISO8859_12)));
22984     }
22985     {
22986         PyDict_SetItemString(d,"FONTENCODING_ISO8859_13", SWIG_From_int((int)(wxFONTENCODING_ISO8859_13)));
22987     }
22988     {
22989         PyDict_SetItemString(d,"FONTENCODING_ISO8859_14", SWIG_From_int((int)(wxFONTENCODING_ISO8859_14)));
22990     }
22991     {
22992         PyDict_SetItemString(d,"FONTENCODING_ISO8859_15", SWIG_From_int((int)(wxFONTENCODING_ISO8859_15)));
22993     }
22994     {
22995         PyDict_SetItemString(d,"FONTENCODING_ISO8859_MAX", SWIG_From_int((int)(wxFONTENCODING_ISO8859_MAX)));
22996     }
22997     {
22998         PyDict_SetItemString(d,"FONTENCODING_KOI8", SWIG_From_int((int)(wxFONTENCODING_KOI8)));
22999     }
23000     {
23001         PyDict_SetItemString(d,"FONTENCODING_KOI8_U", SWIG_From_int((int)(wxFONTENCODING_KOI8_U)));
23002     }
23003     {
23004         PyDict_SetItemString(d,"FONTENCODING_ALTERNATIVE", SWIG_From_int((int)(wxFONTENCODING_ALTERNATIVE)));
23005     }
23006     {
23007         PyDict_SetItemString(d,"FONTENCODING_BULGARIAN", SWIG_From_int((int)(wxFONTENCODING_BULGARIAN)));
23008     }
23009     {
23010         PyDict_SetItemString(d,"FONTENCODING_CP437", SWIG_From_int((int)(wxFONTENCODING_CP437)));
23011     }
23012     {
23013         PyDict_SetItemString(d,"FONTENCODING_CP850", SWIG_From_int((int)(wxFONTENCODING_CP850)));
23014     }
23015     {
23016         PyDict_SetItemString(d,"FONTENCODING_CP852", SWIG_From_int((int)(wxFONTENCODING_CP852)));
23017     }
23018     {
23019         PyDict_SetItemString(d,"FONTENCODING_CP855", SWIG_From_int((int)(wxFONTENCODING_CP855)));
23020     }
23021     {
23022         PyDict_SetItemString(d,"FONTENCODING_CP866", SWIG_From_int((int)(wxFONTENCODING_CP866)));
23023     }
23024     {
23025         PyDict_SetItemString(d,"FONTENCODING_CP874", SWIG_From_int((int)(wxFONTENCODING_CP874)));
23026     }
23027     {
23028         PyDict_SetItemString(d,"FONTENCODING_CP932", SWIG_From_int((int)(wxFONTENCODING_CP932)));
23029     }
23030     {
23031         PyDict_SetItemString(d,"FONTENCODING_CP936", SWIG_From_int((int)(wxFONTENCODING_CP936)));
23032     }
23033     {
23034         PyDict_SetItemString(d,"FONTENCODING_CP949", SWIG_From_int((int)(wxFONTENCODING_CP949)));
23035     }
23036     {
23037         PyDict_SetItemString(d,"FONTENCODING_CP950", SWIG_From_int((int)(wxFONTENCODING_CP950)));
23038     }
23039     {
23040         PyDict_SetItemString(d,"FONTENCODING_CP1250", SWIG_From_int((int)(wxFONTENCODING_CP1250)));
23041     }
23042     {
23043         PyDict_SetItemString(d,"FONTENCODING_CP1251", SWIG_From_int((int)(wxFONTENCODING_CP1251)));
23044     }
23045     {
23046         PyDict_SetItemString(d,"FONTENCODING_CP1252", SWIG_From_int((int)(wxFONTENCODING_CP1252)));
23047     }
23048     {
23049         PyDict_SetItemString(d,"FONTENCODING_CP1253", SWIG_From_int((int)(wxFONTENCODING_CP1253)));
23050     }
23051     {
23052         PyDict_SetItemString(d,"FONTENCODING_CP1254", SWIG_From_int((int)(wxFONTENCODING_CP1254)));
23053     }
23054     {
23055         PyDict_SetItemString(d,"FONTENCODING_CP1255", SWIG_From_int((int)(wxFONTENCODING_CP1255)));
23056     }
23057     {
23058         PyDict_SetItemString(d,"FONTENCODING_CP1256", SWIG_From_int((int)(wxFONTENCODING_CP1256)));
23059     }
23060     {
23061         PyDict_SetItemString(d,"FONTENCODING_CP1257", SWIG_From_int((int)(wxFONTENCODING_CP1257)));
23062     }
23063     {
23064         PyDict_SetItemString(d,"FONTENCODING_CP12_MAX", SWIG_From_int((int)(wxFONTENCODING_CP12_MAX)));
23065     }
23066     {
23067         PyDict_SetItemString(d,"FONTENCODING_UTF7", SWIG_From_int((int)(wxFONTENCODING_UTF7)));
23068     }
23069     {
23070         PyDict_SetItemString(d,"FONTENCODING_UTF8", SWIG_From_int((int)(wxFONTENCODING_UTF8)));
23071     }
23072     {
23073         PyDict_SetItemString(d,"FONTENCODING_EUC_JP", SWIG_From_int((int)(wxFONTENCODING_EUC_JP)));
23074     }
23075     {
23076         PyDict_SetItemString(d,"FONTENCODING_UTF16BE", SWIG_From_int((int)(wxFONTENCODING_UTF16BE)));
23077     }
23078     {
23079         PyDict_SetItemString(d,"FONTENCODING_UTF16LE", SWIG_From_int((int)(wxFONTENCODING_UTF16LE)));
23080     }
23081     {
23082         PyDict_SetItemString(d,"FONTENCODING_UTF32BE", SWIG_From_int((int)(wxFONTENCODING_UTF32BE)));
23083     }
23084     {
23085         PyDict_SetItemString(d,"FONTENCODING_UTF32LE", SWIG_From_int((int)(wxFONTENCODING_UTF32LE)));
23086     }
23087     {
23088         PyDict_SetItemString(d,"FONTENCODING_MACROMAN", SWIG_From_int((int)(wxFONTENCODING_MACROMAN)));
23089     }
23090     {
23091         PyDict_SetItemString(d,"FONTENCODING_MACJAPANESE", SWIG_From_int((int)(wxFONTENCODING_MACJAPANESE)));
23092     }
23093     {
23094         PyDict_SetItemString(d,"FONTENCODING_MACCHINESETRAD", SWIG_From_int((int)(wxFONTENCODING_MACCHINESETRAD)));
23095     }
23096     {
23097         PyDict_SetItemString(d,"FONTENCODING_MACKOREAN", SWIG_From_int((int)(wxFONTENCODING_MACKOREAN)));
23098     }
23099     {
23100         PyDict_SetItemString(d,"FONTENCODING_MACARABIC", SWIG_From_int((int)(wxFONTENCODING_MACARABIC)));
23101     }
23102     {
23103         PyDict_SetItemString(d,"FONTENCODING_MACHEBREW", SWIG_From_int((int)(wxFONTENCODING_MACHEBREW)));
23104     }
23105     {
23106         PyDict_SetItemString(d,"FONTENCODING_MACGREEK", SWIG_From_int((int)(wxFONTENCODING_MACGREEK)));
23107     }
23108     {
23109         PyDict_SetItemString(d,"FONTENCODING_MACCYRILLIC", SWIG_From_int((int)(wxFONTENCODING_MACCYRILLIC)));
23110     }
23111     {
23112         PyDict_SetItemString(d,"FONTENCODING_MACDEVANAGARI", SWIG_From_int((int)(wxFONTENCODING_MACDEVANAGARI)));
23113     }
23114     {
23115         PyDict_SetItemString(d,"FONTENCODING_MACGURMUKHI", SWIG_From_int((int)(wxFONTENCODING_MACGURMUKHI)));
23116     }
23117     {
23118         PyDict_SetItemString(d,"FONTENCODING_MACGUJARATI", SWIG_From_int((int)(wxFONTENCODING_MACGUJARATI)));
23119     }
23120     {
23121         PyDict_SetItemString(d,"FONTENCODING_MACORIYA", SWIG_From_int((int)(wxFONTENCODING_MACORIYA)));
23122     }
23123     {
23124         PyDict_SetItemString(d,"FONTENCODING_MACBENGALI", SWIG_From_int((int)(wxFONTENCODING_MACBENGALI)));
23125     }
23126     {
23127         PyDict_SetItemString(d,"FONTENCODING_MACTAMIL", SWIG_From_int((int)(wxFONTENCODING_MACTAMIL)));
23128     }
23129     {
23130         PyDict_SetItemString(d,"FONTENCODING_MACTELUGU", SWIG_From_int((int)(wxFONTENCODING_MACTELUGU)));
23131     }
23132     {
23133         PyDict_SetItemString(d,"FONTENCODING_MACKANNADA", SWIG_From_int((int)(wxFONTENCODING_MACKANNADA)));
23134     }
23135     {
23136         PyDict_SetItemString(d,"FONTENCODING_MACMALAJALAM", SWIG_From_int((int)(wxFONTENCODING_MACMALAJALAM)));
23137     }
23138     {
23139         PyDict_SetItemString(d,"FONTENCODING_MACSINHALESE", SWIG_From_int((int)(wxFONTENCODING_MACSINHALESE)));
23140     }
23141     {
23142         PyDict_SetItemString(d,"FONTENCODING_MACBURMESE", SWIG_From_int((int)(wxFONTENCODING_MACBURMESE)));
23143     }
23144     {
23145         PyDict_SetItemString(d,"FONTENCODING_MACKHMER", SWIG_From_int((int)(wxFONTENCODING_MACKHMER)));
23146     }
23147     {
23148         PyDict_SetItemString(d,"FONTENCODING_MACTHAI", SWIG_From_int((int)(wxFONTENCODING_MACTHAI)));
23149     }
23150     {
23151         PyDict_SetItemString(d,"FONTENCODING_MACLAOTIAN", SWIG_From_int((int)(wxFONTENCODING_MACLAOTIAN)));
23152     }
23153     {
23154         PyDict_SetItemString(d,"FONTENCODING_MACGEORGIAN", SWIG_From_int((int)(wxFONTENCODING_MACGEORGIAN)));
23155     }
23156     {
23157         PyDict_SetItemString(d,"FONTENCODING_MACARMENIAN", SWIG_From_int((int)(wxFONTENCODING_MACARMENIAN)));
23158     }
23159     {
23160         PyDict_SetItemString(d,"FONTENCODING_MACCHINESESIMP", SWIG_From_int((int)(wxFONTENCODING_MACCHINESESIMP)));
23161     }
23162     {
23163         PyDict_SetItemString(d,"FONTENCODING_MACTIBETAN", SWIG_From_int((int)(wxFONTENCODING_MACTIBETAN)));
23164     }
23165     {
23166         PyDict_SetItemString(d,"FONTENCODING_MACMONGOLIAN", SWIG_From_int((int)(wxFONTENCODING_MACMONGOLIAN)));
23167     }
23168     {
23169         PyDict_SetItemString(d,"FONTENCODING_MACETHIOPIC", SWIG_From_int((int)(wxFONTENCODING_MACETHIOPIC)));
23170     }
23171     {
23172         PyDict_SetItemString(d,"FONTENCODING_MACCENTRALEUR", SWIG_From_int((int)(wxFONTENCODING_MACCENTRALEUR)));
23173     }
23174     {
23175         PyDict_SetItemString(d,"FONTENCODING_MACVIATNAMESE", SWIG_From_int((int)(wxFONTENCODING_MACVIATNAMESE)));
23176     }
23177     {
23178         PyDict_SetItemString(d,"FONTENCODING_MACARABICEXT", SWIG_From_int((int)(wxFONTENCODING_MACARABICEXT)));
23179     }
23180     {
23181         PyDict_SetItemString(d,"FONTENCODING_MACSYMBOL", SWIG_From_int((int)(wxFONTENCODING_MACSYMBOL)));
23182     }
23183     {
23184         PyDict_SetItemString(d,"FONTENCODING_MACDINGBATS", SWIG_From_int((int)(wxFONTENCODING_MACDINGBATS)));
23185     }
23186     {
23187         PyDict_SetItemString(d,"FONTENCODING_MACTURKISH", SWIG_From_int((int)(wxFONTENCODING_MACTURKISH)));
23188     }
23189     {
23190         PyDict_SetItemString(d,"FONTENCODING_MACCROATIAN", SWIG_From_int((int)(wxFONTENCODING_MACCROATIAN)));
23191     }
23192     {
23193         PyDict_SetItemString(d,"FONTENCODING_MACICELANDIC", SWIG_From_int((int)(wxFONTENCODING_MACICELANDIC)));
23194     }
23195     {
23196         PyDict_SetItemString(d,"FONTENCODING_MACROMANIAN", SWIG_From_int((int)(wxFONTENCODING_MACROMANIAN)));
23197     }
23198     {
23199         PyDict_SetItemString(d,"FONTENCODING_MACCELTIC", SWIG_From_int((int)(wxFONTENCODING_MACCELTIC)));
23200     }
23201     {
23202         PyDict_SetItemString(d,"FONTENCODING_MACGAELIC", SWIG_From_int((int)(wxFONTENCODING_MACGAELIC)));
23203     }
23204     {
23205         PyDict_SetItemString(d,"FONTENCODING_MACKEYBOARD", SWIG_From_int((int)(wxFONTENCODING_MACKEYBOARD)));
23206     }
23207     {
23208         PyDict_SetItemString(d,"FONTENCODING_MACMIN", SWIG_From_int((int)(wxFONTENCODING_MACMIN)));
23209     }
23210     {
23211         PyDict_SetItemString(d,"FONTENCODING_MACMAX", SWIG_From_int((int)(wxFONTENCODING_MACMAX)));
23212     }
23213     {
23214         PyDict_SetItemString(d,"FONTENCODING_MAX", SWIG_From_int((int)(wxFONTENCODING_MAX)));
23215     }
23216     {
23217         PyDict_SetItemString(d,"FONTENCODING_UTF16", SWIG_From_int((int)(wxFONTENCODING_UTF16)));
23218     }
23219     {
23220         PyDict_SetItemString(d,"FONTENCODING_UTF32", SWIG_From_int((int)(wxFONTENCODING_UTF32)));
23221     }
23222     {
23223         PyDict_SetItemString(d,"FONTENCODING_UNICODE", SWIG_From_int((int)(wxFONTENCODING_UNICODE)));
23224     }
23225     {
23226         PyDict_SetItemString(d,"FONTENCODING_GB2312", SWIG_From_int((int)(wxFONTENCODING_GB2312)));
23227     }
23228     {
23229         PyDict_SetItemString(d,"FONTENCODING_BIG5", SWIG_From_int((int)(wxFONTENCODING_BIG5)));
23230     }
23231     {
23232         PyDict_SetItemString(d,"FONTENCODING_SHIFT_JIS", SWIG_From_int((int)(wxFONTENCODING_SHIFT_JIS)));
23233     }
23234
23235     wxPyPtrTypeMap_Add("wxFontEnumerator", "wxPyFontEnumerator");
23236
23237     {
23238         PyDict_SetItemString(d,"LANGUAGE_DEFAULT", SWIG_From_int((int)(wxLANGUAGE_DEFAULT)));
23239     }
23240     {
23241         PyDict_SetItemString(d,"LANGUAGE_UNKNOWN", SWIG_From_int((int)(wxLANGUAGE_UNKNOWN)));
23242     }
23243     {
23244         PyDict_SetItemString(d,"LANGUAGE_ABKHAZIAN", SWIG_From_int((int)(wxLANGUAGE_ABKHAZIAN)));
23245     }
23246     {
23247         PyDict_SetItemString(d,"LANGUAGE_AFAR", SWIG_From_int((int)(wxLANGUAGE_AFAR)));
23248     }
23249     {
23250         PyDict_SetItemString(d,"LANGUAGE_AFRIKAANS", SWIG_From_int((int)(wxLANGUAGE_AFRIKAANS)));
23251     }
23252     {
23253         PyDict_SetItemString(d,"LANGUAGE_ALBANIAN", SWIG_From_int((int)(wxLANGUAGE_ALBANIAN)));
23254     }
23255     {
23256         PyDict_SetItemString(d,"LANGUAGE_AMHARIC", SWIG_From_int((int)(wxLANGUAGE_AMHARIC)));
23257     }
23258     {
23259         PyDict_SetItemString(d,"LANGUAGE_ARABIC", SWIG_From_int((int)(wxLANGUAGE_ARABIC)));
23260     }
23261     {
23262         PyDict_SetItemString(d,"LANGUAGE_ARABIC_ALGERIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_ALGERIA)));
23263     }
23264     {
23265         PyDict_SetItemString(d,"LANGUAGE_ARABIC_BAHRAIN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_BAHRAIN)));
23266     }
23267     {
23268         PyDict_SetItemString(d,"LANGUAGE_ARABIC_EGYPT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_EGYPT)));
23269     }
23270     {
23271         PyDict_SetItemString(d,"LANGUAGE_ARABIC_IRAQ", SWIG_From_int((int)(wxLANGUAGE_ARABIC_IRAQ)));
23272     }
23273     {
23274         PyDict_SetItemString(d,"LANGUAGE_ARABIC_JORDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_JORDAN)));
23275     }
23276     {
23277         PyDict_SetItemString(d,"LANGUAGE_ARABIC_KUWAIT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_KUWAIT)));
23278     }
23279     {
23280         PyDict_SetItemString(d,"LANGUAGE_ARABIC_LEBANON", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LEBANON)));
23281     }
23282     {
23283         PyDict_SetItemString(d,"LANGUAGE_ARABIC_LIBYA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LIBYA)));
23284     }
23285     {
23286         PyDict_SetItemString(d,"LANGUAGE_ARABIC_MOROCCO", SWIG_From_int((int)(wxLANGUAGE_ARABIC_MOROCCO)));
23287     }
23288     {
23289         PyDict_SetItemString(d,"LANGUAGE_ARABIC_OMAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_OMAN)));
23290     }
23291     {
23292         PyDict_SetItemString(d,"LANGUAGE_ARABIC_QATAR", SWIG_From_int((int)(wxLANGUAGE_ARABIC_QATAR)));
23293     }
23294     {
23295         PyDict_SetItemString(d,"LANGUAGE_ARABIC_SAUDI_ARABIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SAUDI_ARABIA)));
23296     }
23297     {
23298         PyDict_SetItemString(d,"LANGUAGE_ARABIC_SUDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SUDAN)));
23299     }
23300     {
23301         PyDict_SetItemString(d,"LANGUAGE_ARABIC_SYRIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SYRIA)));
23302     }
23303     {
23304         PyDict_SetItemString(d,"LANGUAGE_ARABIC_TUNISIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_TUNISIA)));
23305     }
23306     {
23307         PyDict_SetItemString(d,"LANGUAGE_ARABIC_UAE", SWIG_From_int((int)(wxLANGUAGE_ARABIC_UAE)));
23308     }
23309     {
23310         PyDict_SetItemString(d,"LANGUAGE_ARABIC_YEMEN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_YEMEN)));
23311     }
23312     {
23313         PyDict_SetItemString(d,"LANGUAGE_ARMENIAN", SWIG_From_int((int)(wxLANGUAGE_ARMENIAN)));
23314     }
23315     {
23316         PyDict_SetItemString(d,"LANGUAGE_ASSAMESE", SWIG_From_int((int)(wxLANGUAGE_ASSAMESE)));
23317     }
23318     {
23319         PyDict_SetItemString(d,"LANGUAGE_AYMARA", SWIG_From_int((int)(wxLANGUAGE_AYMARA)));
23320     }
23321     {
23322         PyDict_SetItemString(d,"LANGUAGE_AZERI", SWIG_From_int((int)(wxLANGUAGE_AZERI)));
23323     }
23324     {
23325         PyDict_SetItemString(d,"LANGUAGE_AZERI_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_AZERI_CYRILLIC)));
23326     }
23327     {
23328         PyDict_SetItemString(d,"LANGUAGE_AZERI_LATIN", SWIG_From_int((int)(wxLANGUAGE_AZERI_LATIN)));
23329     }
23330     {
23331         PyDict_SetItemString(d,"LANGUAGE_BASHKIR", SWIG_From_int((int)(wxLANGUAGE_BASHKIR)));
23332     }
23333     {
23334         PyDict_SetItemString(d,"LANGUAGE_BASQUE", SWIG_From_int((int)(wxLANGUAGE_BASQUE)));
23335     }
23336     {
23337         PyDict_SetItemString(d,"LANGUAGE_BELARUSIAN", SWIG_From_int((int)(wxLANGUAGE_BELARUSIAN)));
23338     }
23339     {
23340         PyDict_SetItemString(d,"LANGUAGE_BENGALI", SWIG_From_int((int)(wxLANGUAGE_BENGALI)));
23341     }
23342     {
23343         PyDict_SetItemString(d,"LANGUAGE_BHUTANI", SWIG_From_int((int)(wxLANGUAGE_BHUTANI)));
23344     }
23345     {
23346         PyDict_SetItemString(d,"LANGUAGE_BIHARI", SWIG_From_int((int)(wxLANGUAGE_BIHARI)));
23347     }
23348     {
23349         PyDict_SetItemString(d,"LANGUAGE_BISLAMA", SWIG_From_int((int)(wxLANGUAGE_BISLAMA)));
23350     }
23351     {
23352         PyDict_SetItemString(d,"LANGUAGE_BRETON", SWIG_From_int((int)(wxLANGUAGE_BRETON)));
23353     }
23354     {
23355         PyDict_SetItemString(d,"LANGUAGE_BULGARIAN", SWIG_From_int((int)(wxLANGUAGE_BULGARIAN)));
23356     }
23357     {
23358         PyDict_SetItemString(d,"LANGUAGE_BURMESE", SWIG_From_int((int)(wxLANGUAGE_BURMESE)));
23359     }
23360     {
23361         PyDict_SetItemString(d,"LANGUAGE_CAMBODIAN", SWIG_From_int((int)(wxLANGUAGE_CAMBODIAN)));
23362     }
23363     {
23364         PyDict_SetItemString(d,"LANGUAGE_CATALAN", SWIG_From_int((int)(wxLANGUAGE_CATALAN)));
23365     }
23366     {
23367         PyDict_SetItemString(d,"LANGUAGE_CHINESE", SWIG_From_int((int)(wxLANGUAGE_CHINESE)));
23368     }
23369     {
23370         PyDict_SetItemString(d,"LANGUAGE_CHINESE_SIMPLIFIED", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SIMPLIFIED)));
23371     }
23372     {
23373         PyDict_SetItemString(d,"LANGUAGE_CHINESE_TRADITIONAL", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TRADITIONAL)));
23374     }
23375     {
23376         PyDict_SetItemString(d,"LANGUAGE_CHINESE_HONGKONG", SWIG_From_int((int)(wxLANGUAGE_CHINESE_HONGKONG)));
23377     }
23378     {
23379         PyDict_SetItemString(d,"LANGUAGE_CHINESE_MACAU", SWIG_From_int((int)(wxLANGUAGE_CHINESE_MACAU)));
23380     }
23381     {
23382         PyDict_SetItemString(d,"LANGUAGE_CHINESE_SINGAPORE", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SINGAPORE)));
23383     }
23384     {
23385         PyDict_SetItemString(d,"LANGUAGE_CHINESE_TAIWAN", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TAIWAN)));
23386     }
23387     {
23388         PyDict_SetItemString(d,"LANGUAGE_CORSICAN", SWIG_From_int((int)(wxLANGUAGE_CORSICAN)));
23389     }
23390     {
23391         PyDict_SetItemString(d,"LANGUAGE_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_CROATIAN)));
23392     }
23393     {
23394         PyDict_SetItemString(d,"LANGUAGE_CZECH", SWIG_From_int((int)(wxLANGUAGE_CZECH)));
23395     }
23396     {
23397         PyDict_SetItemString(d,"LANGUAGE_DANISH", SWIG_From_int((int)(wxLANGUAGE_DANISH)));
23398     }
23399     {
23400         PyDict_SetItemString(d,"LANGUAGE_DUTCH", SWIG_From_int((int)(wxLANGUAGE_DUTCH)));
23401     }
23402     {
23403         PyDict_SetItemString(d,"LANGUAGE_DUTCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_DUTCH_BELGIAN)));
23404     }
23405     {
23406         PyDict_SetItemString(d,"LANGUAGE_ENGLISH", SWIG_From_int((int)(wxLANGUAGE_ENGLISH)));
23407     }
23408     {
23409         PyDict_SetItemString(d,"LANGUAGE_ENGLISH_UK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_UK)));
23410     }
23411     {
23412         PyDict_SetItemString(d,"LANGUAGE_ENGLISH_US", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_US)));
23413     }
23414     {
23415         PyDict_SetItemString(d,"LANGUAGE_ENGLISH_AUSTRALIA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_AUSTRALIA)));
23416     }
23417     {
23418         PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BELIZE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BELIZE)));
23419     }
23420     {
23421         PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BOTSWANA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BOTSWANA)));
23422     }
23423     {
23424         PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CANADA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CANADA)));
23425     }
23426     {
23427         PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CARIBBEAN", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CARIBBEAN)));
23428     }
23429     {
23430         PyDict_SetItemString(d,"LANGUAGE_ENGLISH_DENMARK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_DENMARK)));
23431     }
23432     {
23433         PyDict_SetItemString(d,"LANGUAGE_ENGLISH_EIRE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_EIRE)));
23434     }
23435     {
23436         PyDict_SetItemString(d,"LANGUAGE_ENGLISH_JAMAICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_JAMAICA)));
23437     }
23438     {
23439         PyDict_SetItemString(d,"LANGUAGE_ENGLISH_NEW_ZEALAND", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_NEW_ZEALAND)));
23440     }
23441     {
23442         PyDict_SetItemString(d,"LANGUAGE_ENGLISH_PHILIPPINES", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_PHILIPPINES)));
23443     }
23444     {
23445         PyDict_SetItemString(d,"LANGUAGE_ENGLISH_SOUTH_AFRICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_SOUTH_AFRICA)));
23446     }
23447     {
23448         PyDict_SetItemString(d,"LANGUAGE_ENGLISH_TRINIDAD", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_TRINIDAD)));
23449     }
23450     {
23451         PyDict_SetItemString(d,"LANGUAGE_ENGLISH_ZIMBABWE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_ZIMBABWE)));
23452     }
23453     {
23454         PyDict_SetItemString(d,"LANGUAGE_ESPERANTO", SWIG_From_int((int)(wxLANGUAGE_ESPERANTO)));
23455     }
23456     {
23457         PyDict_SetItemString(d,"LANGUAGE_ESTONIAN", SWIG_From_int((int)(wxLANGUAGE_ESTONIAN)));
23458     }
23459     {
23460         PyDict_SetItemString(d,"LANGUAGE_FAEROESE", SWIG_From_int((int)(wxLANGUAGE_FAEROESE)));
23461     }
23462     {
23463         PyDict_SetItemString(d,"LANGUAGE_FARSI", SWIG_From_int((int)(wxLANGUAGE_FARSI)));
23464     }
23465     {
23466         PyDict_SetItemString(d,"LANGUAGE_FIJI", SWIG_From_int((int)(wxLANGUAGE_FIJI)));
23467     }
23468     {
23469         PyDict_SetItemString(d,"LANGUAGE_FINNISH", SWIG_From_int((int)(wxLANGUAGE_FINNISH)));
23470     }
23471     {
23472         PyDict_SetItemString(d,"LANGUAGE_FRENCH", SWIG_From_int((int)(wxLANGUAGE_FRENCH)));
23473     }
23474     {
23475         PyDict_SetItemString(d,"LANGUAGE_FRENCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_BELGIAN)));
23476     }
23477     {
23478         PyDict_SetItemString(d,"LANGUAGE_FRENCH_CANADIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_CANADIAN)));
23479     }
23480     {
23481         PyDict_SetItemString(d,"LANGUAGE_FRENCH_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_FRENCH_LUXEMBOURG)));
23482     }
23483     {
23484         PyDict_SetItemString(d,"LANGUAGE_FRENCH_MONACO", SWIG_From_int((int)(wxLANGUAGE_FRENCH_MONACO)));
23485     }
23486     {
23487         PyDict_SetItemString(d,"LANGUAGE_FRENCH_SWISS", SWIG_From_int((int)(wxLANGUAGE_FRENCH_SWISS)));
23488     }
23489     {
23490         PyDict_SetItemString(d,"LANGUAGE_FRISIAN", SWIG_From_int((int)(wxLANGUAGE_FRISIAN)));
23491     }
23492     {
23493         PyDict_SetItemString(d,"LANGUAGE_GALICIAN", SWIG_From_int((int)(wxLANGUAGE_GALICIAN)));
23494     }
23495     {
23496         PyDict_SetItemString(d,"LANGUAGE_GEORGIAN", SWIG_From_int((int)(wxLANGUAGE_GEORGIAN)));
23497     }
23498     {
23499         PyDict_SetItemString(d,"LANGUAGE_GERMAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN)));
23500     }
23501     {
23502         PyDict_SetItemString(d,"LANGUAGE_GERMAN_AUSTRIAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_AUSTRIAN)));
23503     }
23504     {
23505         PyDict_SetItemString(d,"LANGUAGE_GERMAN_BELGIUM", SWIG_From_int((int)(wxLANGUAGE_GERMAN_BELGIUM)));
23506     }
23507     {
23508         PyDict_SetItemString(d,"LANGUAGE_GERMAN_LIECHTENSTEIN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LIECHTENSTEIN)));
23509     }
23510     {
23511         PyDict_SetItemString(d,"LANGUAGE_GERMAN_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LUXEMBOURG)));
23512     }
23513     {
23514         PyDict_SetItemString(d,"LANGUAGE_GERMAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_GERMAN_SWISS)));
23515     }
23516     {
23517         PyDict_SetItemString(d,"LANGUAGE_GREEK", SWIG_From_int((int)(wxLANGUAGE_GREEK)));
23518     }
23519     {
23520         PyDict_SetItemString(d,"LANGUAGE_GREENLANDIC", SWIG_From_int((int)(wxLANGUAGE_GREENLANDIC)));
23521     }
23522     {
23523         PyDict_SetItemString(d,"LANGUAGE_GUARANI", SWIG_From_int((int)(wxLANGUAGE_GUARANI)));
23524     }
23525     {
23526         PyDict_SetItemString(d,"LANGUAGE_GUJARATI", SWIG_From_int((int)(wxLANGUAGE_GUJARATI)));
23527     }
23528     {
23529         PyDict_SetItemString(d,"LANGUAGE_HAUSA", SWIG_From_int((int)(wxLANGUAGE_HAUSA)));
23530     }
23531     {
23532         PyDict_SetItemString(d,"LANGUAGE_HEBREW", SWIG_From_int((int)(wxLANGUAGE_HEBREW)));
23533     }
23534     {
23535         PyDict_SetItemString(d,"LANGUAGE_HINDI", SWIG_From_int((int)(wxLANGUAGE_HINDI)));
23536     }
23537     {
23538         PyDict_SetItemString(d,"LANGUAGE_HUNGARIAN", SWIG_From_int((int)(wxLANGUAGE_HUNGARIAN)));
23539     }
23540     {
23541         PyDict_SetItemString(d,"LANGUAGE_ICELANDIC", SWIG_From_int((int)(wxLANGUAGE_ICELANDIC)));
23542     }
23543     {
23544         PyDict_SetItemString(d,"LANGUAGE_INDONESIAN", SWIG_From_int((int)(wxLANGUAGE_INDONESIAN)));
23545     }
23546     {
23547         PyDict_SetItemString(d,"LANGUAGE_INTERLINGUA", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUA)));
23548     }
23549     {
23550         PyDict_SetItemString(d,"LANGUAGE_INTERLINGUE", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUE)));
23551     }
23552     {
23553         PyDict_SetItemString(d,"LANGUAGE_INUKTITUT", SWIG_From_int((int)(wxLANGUAGE_INUKTITUT)));
23554     }
23555     {
23556         PyDict_SetItemString(d,"LANGUAGE_INUPIAK", SWIG_From_int((int)(wxLANGUAGE_INUPIAK)));
23557     }
23558     {
23559         PyDict_SetItemString(d,"LANGUAGE_IRISH", SWIG_From_int((int)(wxLANGUAGE_IRISH)));
23560     }
23561     {
23562         PyDict_SetItemString(d,"LANGUAGE_ITALIAN", SWIG_From_int((int)(wxLANGUAGE_ITALIAN)));
23563     }
23564     {
23565         PyDict_SetItemString(d,"LANGUAGE_ITALIAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_ITALIAN_SWISS)));
23566     }
23567     {
23568         PyDict_SetItemString(d,"LANGUAGE_JAPANESE", SWIG_From_int((int)(wxLANGUAGE_JAPANESE)));
23569     }
23570     {
23571         PyDict_SetItemString(d,"LANGUAGE_JAVANESE", SWIG_From_int((int)(wxLANGUAGE_JAVANESE)));
23572     }
23573     {
23574         PyDict_SetItemString(d,"LANGUAGE_KANNADA", SWIG_From_int((int)(wxLANGUAGE_KANNADA)));
23575     }
23576     {
23577         PyDict_SetItemString(d,"LANGUAGE_KASHMIRI", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI)));
23578     }
23579     {
23580         PyDict_SetItemString(d,"LANGUAGE_KASHMIRI_INDIA", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI_INDIA)));
23581     }
23582     {
23583         PyDict_SetItemString(d,"LANGUAGE_KAZAKH", SWIG_From_int((int)(wxLANGUAGE_KAZAKH)));
23584     }
23585     {
23586         PyDict_SetItemString(d,"LANGUAGE_KERNEWEK", SWIG_From_int((int)(wxLANGUAGE_KERNEWEK)));
23587     }
23588     {
23589         PyDict_SetItemString(d,"LANGUAGE_KINYARWANDA", SWIG_From_int((int)(wxLANGUAGE_KINYARWANDA)));
23590     }
23591     {
23592         PyDict_SetItemString(d,"LANGUAGE_KIRGHIZ", SWIG_From_int((int)(wxLANGUAGE_KIRGHIZ)));
23593     }
23594     {
23595         PyDict_SetItemString(d,"LANGUAGE_KIRUNDI", SWIG_From_int((int)(wxLANGUAGE_KIRUNDI)));
23596     }
23597     {
23598         PyDict_SetItemString(d,"LANGUAGE_KONKANI", SWIG_From_int((int)(wxLANGUAGE_KONKANI)));
23599     }
23600     {
23601         PyDict_SetItemString(d,"LANGUAGE_KOREAN", SWIG_From_int((int)(wxLANGUAGE_KOREAN)));
23602     }
23603     {
23604         PyDict_SetItemString(d,"LANGUAGE_KURDISH", SWIG_From_int((int)(wxLANGUAGE_KURDISH)));
23605     }
23606     {
23607         PyDict_SetItemString(d,"LANGUAGE_LAOTHIAN", SWIG_From_int((int)(wxLANGUAGE_LAOTHIAN)));
23608     }
23609     {
23610         PyDict_SetItemString(d,"LANGUAGE_LATIN", SWIG_From_int((int)(wxLANGUAGE_LATIN)));
23611     }
23612     {
23613         PyDict_SetItemString(d,"LANGUAGE_LATVIAN", SWIG_From_int((int)(wxLANGUAGE_LATVIAN)));
23614     }
23615     {
23616         PyDict_SetItemString(d,"LANGUAGE_LINGALA", SWIG_From_int((int)(wxLANGUAGE_LINGALA)));
23617     }
23618     {
23619         PyDict_SetItemString(d,"LANGUAGE_LITHUANIAN", SWIG_From_int((int)(wxLANGUAGE_LITHUANIAN)));
23620     }
23621     {
23622         PyDict_SetItemString(d,"LANGUAGE_MACEDONIAN", SWIG_From_int((int)(wxLANGUAGE_MACEDONIAN)));
23623     }
23624     {
23625         PyDict_SetItemString(d,"LANGUAGE_MALAGASY", SWIG_From_int((int)(wxLANGUAGE_MALAGASY)));
23626     }
23627     {
23628         PyDict_SetItemString(d,"LANGUAGE_MALAY", SWIG_From_int((int)(wxLANGUAGE_MALAY)));
23629     }
23630     {
23631         PyDict_SetItemString(d,"LANGUAGE_MALAYALAM", SWIG_From_int((int)(wxLANGUAGE_MALAYALAM)));
23632     }
23633     {
23634         PyDict_SetItemString(d,"LANGUAGE_MALAY_BRUNEI_DARUSSALAM", SWIG_From_int((int)(wxLANGUAGE_MALAY_BRUNEI_DARUSSALAM)));
23635     }
23636     {
23637         PyDict_SetItemString(d,"LANGUAGE_MALAY_MALAYSIA", SWIG_From_int((int)(wxLANGUAGE_MALAY_MALAYSIA)));
23638     }
23639     {
23640         PyDict_SetItemString(d,"LANGUAGE_MALTESE", SWIG_From_int((int)(wxLANGUAGE_MALTESE)));
23641     }
23642     {
23643         PyDict_SetItemString(d,"LANGUAGE_MANIPURI", SWIG_From_int((int)(wxLANGUAGE_MANIPURI)));
23644     }
23645     {
23646         PyDict_SetItemString(d,"LANGUAGE_MAORI", SWIG_From_int((int)(wxLANGUAGE_MAORI)));
23647     }
23648     {
23649         PyDict_SetItemString(d,"LANGUAGE_MARATHI", SWIG_From_int((int)(wxLANGUAGE_MARATHI)));
23650     }
23651     {
23652         PyDict_SetItemString(d,"LANGUAGE_MOLDAVIAN", SWIG_From_int((int)(wxLANGUAGE_MOLDAVIAN)));
23653     }
23654     {
23655         PyDict_SetItemString(d,"LANGUAGE_MONGOLIAN", SWIG_From_int((int)(wxLANGUAGE_MONGOLIAN)));
23656     }
23657     {
23658         PyDict_SetItemString(d,"LANGUAGE_NAURU", SWIG_From_int((int)(wxLANGUAGE_NAURU)));
23659     }
23660     {
23661         PyDict_SetItemString(d,"LANGUAGE_NEPALI", SWIG_From_int((int)(wxLANGUAGE_NEPALI)));
23662     }
23663     {
23664         PyDict_SetItemString(d,"LANGUAGE_NEPALI_INDIA", SWIG_From_int((int)(wxLANGUAGE_NEPALI_INDIA)));
23665     }
23666     {
23667         PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_BOKMAL", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_BOKMAL)));
23668     }
23669     {
23670         PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_NYNORSK", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_NYNORSK)));
23671     }
23672     {
23673         PyDict_SetItemString(d,"LANGUAGE_OCCITAN", SWIG_From_int((int)(wxLANGUAGE_OCCITAN)));
23674     }
23675     {
23676         PyDict_SetItemString(d,"LANGUAGE_ORIYA", SWIG_From_int((int)(wxLANGUAGE_ORIYA)));
23677     }
23678     {
23679         PyDict_SetItemString(d,"LANGUAGE_OROMO", SWIG_From_int((int)(wxLANGUAGE_OROMO)));
23680     }
23681     {
23682         PyDict_SetItemString(d,"LANGUAGE_PASHTO", SWIG_From_int((int)(wxLANGUAGE_PASHTO)));
23683     }
23684     {
23685         PyDict_SetItemString(d,"LANGUAGE_POLISH", SWIG_From_int((int)(wxLANGUAGE_POLISH)));
23686     }
23687     {
23688         PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE)));
23689     }
23690     {
23691         PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE_BRAZILIAN", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE_BRAZILIAN)));
23692     }
23693     {
23694         PyDict_SetItemString(d,"LANGUAGE_PUNJABI", SWIG_From_int((int)(wxLANGUAGE_PUNJABI)));
23695     }
23696     {
23697         PyDict_SetItemString(d,"LANGUAGE_QUECHUA", SWIG_From_int((int)(wxLANGUAGE_QUECHUA)));
23698     }
23699     {
23700         PyDict_SetItemString(d,"LANGUAGE_RHAETO_ROMANCE", SWIG_From_int((int)(wxLANGUAGE_RHAETO_ROMANCE)));
23701     }
23702     {
23703         PyDict_SetItemString(d,"LANGUAGE_ROMANIAN", SWIG_From_int((int)(wxLANGUAGE_ROMANIAN)));
23704     }
23705     {
23706         PyDict_SetItemString(d,"LANGUAGE_RUSSIAN", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN)));
23707     }
23708     {
23709         PyDict_SetItemString(d,"LANGUAGE_RUSSIAN_UKRAINE", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN_UKRAINE)));
23710     }
23711     {
23712         PyDict_SetItemString(d,"LANGUAGE_SAMOAN", SWIG_From_int((int)(wxLANGUAGE_SAMOAN)));
23713     }
23714     {
23715         PyDict_SetItemString(d,"LANGUAGE_SANGHO", SWIG_From_int((int)(wxLANGUAGE_SANGHO)));
23716     }
23717     {
23718         PyDict_SetItemString(d,"LANGUAGE_SANSKRIT", SWIG_From_int((int)(wxLANGUAGE_SANSKRIT)));
23719     }
23720     {
23721         PyDict_SetItemString(d,"LANGUAGE_SCOTS_GAELIC", SWIG_From_int((int)(wxLANGUAGE_SCOTS_GAELIC)));
23722     }
23723     {
23724         PyDict_SetItemString(d,"LANGUAGE_SERBIAN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN)));
23725     }
23726     {
23727         PyDict_SetItemString(d,"LANGUAGE_SERBIAN_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_CYRILLIC)));
23728     }
23729     {
23730         PyDict_SetItemString(d,"LANGUAGE_SERBIAN_LATIN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_LATIN)));
23731     }
23732     {
23733         PyDict_SetItemString(d,"LANGUAGE_SERBO_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_SERBO_CROATIAN)));
23734     }
23735     {
23736         PyDict_SetItemString(d,"LANGUAGE_SESOTHO", SWIG_From_int((int)(wxLANGUAGE_SESOTHO)));
23737     }
23738     {
23739         PyDict_SetItemString(d,"LANGUAGE_SETSWANA", SWIG_From_int((int)(wxLANGUAGE_SETSWANA)));
23740     }
23741     {
23742         PyDict_SetItemString(d,"LANGUAGE_SHONA", SWIG_From_int((int)(wxLANGUAGE_SHONA)));
23743     }
23744     {
23745         PyDict_SetItemString(d,"LANGUAGE_SINDHI", SWIG_From_int((int)(wxLANGUAGE_SINDHI)));
23746     }
23747     {
23748         PyDict_SetItemString(d,"LANGUAGE_SINHALESE", SWIG_From_int((int)(wxLANGUAGE_SINHALESE)));
23749     }
23750     {
23751         PyDict_SetItemString(d,"LANGUAGE_SISWATI", SWIG_From_int((int)(wxLANGUAGE_SISWATI)));
23752     }
23753     {
23754         PyDict_SetItemString(d,"LANGUAGE_SLOVAK", SWIG_From_int((int)(wxLANGUAGE_SLOVAK)));
23755     }
23756     {
23757         PyDict_SetItemString(d,"LANGUAGE_SLOVENIAN", SWIG_From_int((int)(wxLANGUAGE_SLOVENIAN)));
23758     }
23759     {
23760         PyDict_SetItemString(d,"LANGUAGE_SOMALI", SWIG_From_int((int)(wxLANGUAGE_SOMALI)));
23761     }
23762     {
23763         PyDict_SetItemString(d,"LANGUAGE_SPANISH", SWIG_From_int((int)(wxLANGUAGE_SPANISH)));
23764     }
23765     {
23766         PyDict_SetItemString(d,"LANGUAGE_SPANISH_ARGENTINA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ARGENTINA)));
23767     }
23768     {
23769         PyDict_SetItemString(d,"LANGUAGE_SPANISH_BOLIVIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_BOLIVIA)));
23770     }
23771     {
23772         PyDict_SetItemString(d,"LANGUAGE_SPANISH_CHILE", SWIG_From_int((int)(wxLANGUAGE_SPANISH_CHILE)));
23773     }
23774     {
23775         PyDict_SetItemString(d,"LANGUAGE_SPANISH_COLOMBIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COLOMBIA)));
23776     }
23777     {
23778         PyDict_SetItemString(d,"LANGUAGE_SPANISH_COSTA_RICA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COSTA_RICA)));
23779     }
23780     {
23781         PyDict_SetItemString(d,"LANGUAGE_SPANISH_DOMINICAN_REPUBLIC", SWIG_From_int((int)(wxLANGUAGE_SPANISH_DOMINICAN_REPUBLIC)));
23782     }
23783     {
23784         PyDict_SetItemString(d,"LANGUAGE_SPANISH_ECUADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ECUADOR)));
23785     }
23786     {
23787         PyDict_SetItemString(d,"LANGUAGE_SPANISH_EL_SALVADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_EL_SALVADOR)));
23788     }
23789     {
23790         PyDict_SetItemString(d,"LANGUAGE_SPANISH_GUATEMALA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_GUATEMALA)));
23791     }
23792     {
23793         PyDict_SetItemString(d,"LANGUAGE_SPANISH_HONDURAS", SWIG_From_int((int)(wxLANGUAGE_SPANISH_HONDURAS)));
23794     }
23795     {
23796         PyDict_SetItemString(d,"LANGUAGE_SPANISH_MEXICAN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MEXICAN)));
23797     }
23798     {
23799         PyDict_SetItemString(d,"LANGUAGE_SPANISH_MODERN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MODERN)));
23800     }
23801     {
23802         PyDict_SetItemString(d,"LANGUAGE_SPANISH_NICARAGUA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_NICARAGUA)));
23803     }
23804     {
23805         PyDict_SetItemString(d,"LANGUAGE_SPANISH_PANAMA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PANAMA)));
23806     }
23807     {
23808         PyDict_SetItemString(d,"LANGUAGE_SPANISH_PARAGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PARAGUAY)));
23809     }
23810     {
23811         PyDict_SetItemString(d,"LANGUAGE_SPANISH_PERU", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PERU)));
23812     }
23813     {
23814         PyDict_SetItemString(d,"LANGUAGE_SPANISH_PUERTO_RICO", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PUERTO_RICO)));
23815     }
23816     {
23817         PyDict_SetItemString(d,"LANGUAGE_SPANISH_URUGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_URUGUAY)));
23818     }
23819     {
23820         PyDict_SetItemString(d,"LANGUAGE_SPANISH_US", SWIG_From_int((int)(wxLANGUAGE_SPANISH_US)));
23821     }
23822     {
23823         PyDict_SetItemString(d,"LANGUAGE_SPANISH_VENEZUELA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_VENEZUELA)));
23824     }
23825     {
23826         PyDict_SetItemString(d,"LANGUAGE_SUNDANESE", SWIG_From_int((int)(wxLANGUAGE_SUNDANESE)));
23827     }
23828     {
23829         PyDict_SetItemString(d,"LANGUAGE_SWAHILI", SWIG_From_int((int)(wxLANGUAGE_SWAHILI)));
23830     }
23831     {
23832         PyDict_SetItemString(d,"LANGUAGE_SWEDISH", SWIG_From_int((int)(wxLANGUAGE_SWEDISH)));
23833     }
23834     {
23835         PyDict_SetItemString(d,"LANGUAGE_SWEDISH_FINLAND", SWIG_From_int((int)(wxLANGUAGE_SWEDISH_FINLAND)));
23836     }
23837     {
23838         PyDict_SetItemString(d,"LANGUAGE_TAGALOG", SWIG_From_int((int)(wxLANGUAGE_TAGALOG)));
23839     }
23840     {
23841         PyDict_SetItemString(d,"LANGUAGE_TAJIK", SWIG_From_int((int)(wxLANGUAGE_TAJIK)));
23842     }
23843     {
23844         PyDict_SetItemString(d,"LANGUAGE_TAMIL", SWIG_From_int((int)(wxLANGUAGE_TAMIL)));
23845     }
23846     {
23847         PyDict_SetItemString(d,"LANGUAGE_TATAR", SWIG_From_int((int)(wxLANGUAGE_TATAR)));
23848     }
23849     {
23850         PyDict_SetItemString(d,"LANGUAGE_TELUGU", SWIG_From_int((int)(wxLANGUAGE_TELUGU)));
23851     }
23852     {
23853         PyDict_SetItemString(d,"LANGUAGE_THAI", SWIG_From_int((int)(wxLANGUAGE_THAI)));
23854     }
23855     {
23856         PyDict_SetItemString(d,"LANGUAGE_TIBETAN", SWIG_From_int((int)(wxLANGUAGE_TIBETAN)));
23857     }
23858     {
23859         PyDict_SetItemString(d,"LANGUAGE_TIGRINYA", SWIG_From_int((int)(wxLANGUAGE_TIGRINYA)));
23860     }
23861     {
23862         PyDict_SetItemString(d,"LANGUAGE_TONGA", SWIG_From_int((int)(wxLANGUAGE_TONGA)));
23863     }
23864     {
23865         PyDict_SetItemString(d,"LANGUAGE_TSONGA", SWIG_From_int((int)(wxLANGUAGE_TSONGA)));
23866     }
23867     {
23868         PyDict_SetItemString(d,"LANGUAGE_TURKISH", SWIG_From_int((int)(wxLANGUAGE_TURKISH)));
23869     }
23870     {
23871         PyDict_SetItemString(d,"LANGUAGE_TURKMEN", SWIG_From_int((int)(wxLANGUAGE_TURKMEN)));
23872     }
23873     {
23874         PyDict_SetItemString(d,"LANGUAGE_TWI", SWIG_From_int((int)(wxLANGUAGE_TWI)));
23875     }
23876     {
23877         PyDict_SetItemString(d,"LANGUAGE_UIGHUR", SWIG_From_int((int)(wxLANGUAGE_UIGHUR)));
23878     }
23879     {
23880         PyDict_SetItemString(d,"LANGUAGE_UKRAINIAN", SWIG_From_int((int)(wxLANGUAGE_UKRAINIAN)));
23881     }
23882     {
23883         PyDict_SetItemString(d,"LANGUAGE_URDU", SWIG_From_int((int)(wxLANGUAGE_URDU)));
23884     }
23885     {
23886         PyDict_SetItemString(d,"LANGUAGE_URDU_INDIA", SWIG_From_int((int)(wxLANGUAGE_URDU_INDIA)));
23887     }
23888     {
23889         PyDict_SetItemString(d,"LANGUAGE_URDU_PAKISTAN", SWIG_From_int((int)(wxLANGUAGE_URDU_PAKISTAN)));
23890     }
23891     {
23892         PyDict_SetItemString(d,"LANGUAGE_UZBEK", SWIG_From_int((int)(wxLANGUAGE_UZBEK)));
23893     }
23894     {
23895         PyDict_SetItemString(d,"LANGUAGE_UZBEK_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_UZBEK_CYRILLIC)));
23896     }
23897     {
23898         PyDict_SetItemString(d,"LANGUAGE_UZBEK_LATIN", SWIG_From_int((int)(wxLANGUAGE_UZBEK_LATIN)));
23899     }
23900     {
23901         PyDict_SetItemString(d,"LANGUAGE_VIETNAMESE", SWIG_From_int((int)(wxLANGUAGE_VIETNAMESE)));
23902     }
23903     {
23904         PyDict_SetItemString(d,"LANGUAGE_VOLAPUK", SWIG_From_int((int)(wxLANGUAGE_VOLAPUK)));
23905     }
23906     {
23907         PyDict_SetItemString(d,"LANGUAGE_WELSH", SWIG_From_int((int)(wxLANGUAGE_WELSH)));
23908     }
23909     {
23910         PyDict_SetItemString(d,"LANGUAGE_WOLOF", SWIG_From_int((int)(wxLANGUAGE_WOLOF)));
23911     }
23912     {
23913         PyDict_SetItemString(d,"LANGUAGE_XHOSA", SWIG_From_int((int)(wxLANGUAGE_XHOSA)));
23914     }
23915     {
23916         PyDict_SetItemString(d,"LANGUAGE_YIDDISH", SWIG_From_int((int)(wxLANGUAGE_YIDDISH)));
23917     }
23918     {
23919         PyDict_SetItemString(d,"LANGUAGE_YORUBA", SWIG_From_int((int)(wxLANGUAGE_YORUBA)));
23920     }
23921     {
23922         PyDict_SetItemString(d,"LANGUAGE_ZHUANG", SWIG_From_int((int)(wxLANGUAGE_ZHUANG)));
23923     }
23924     {
23925         PyDict_SetItemString(d,"LANGUAGE_ZULU", SWIG_From_int((int)(wxLANGUAGE_ZULU)));
23926     }
23927     {
23928         PyDict_SetItemString(d,"LANGUAGE_USER_DEFINED", SWIG_From_int((int)(wxLANGUAGE_USER_DEFINED)));
23929     }
23930     {
23931         PyDict_SetItemString(d,"LOCALE_CAT_NUMBER", SWIG_From_int((int)(wxLOCALE_CAT_NUMBER)));
23932     }
23933     {
23934         PyDict_SetItemString(d,"LOCALE_CAT_DATE", SWIG_From_int((int)(wxLOCALE_CAT_DATE)));
23935     }
23936     {
23937         PyDict_SetItemString(d,"LOCALE_CAT_MONEY", SWIG_From_int((int)(wxLOCALE_CAT_MONEY)));
23938     }
23939     {
23940         PyDict_SetItemString(d,"LOCALE_CAT_MAX", SWIG_From_int((int)(wxLOCALE_CAT_MAX)));
23941     }
23942     {
23943         PyDict_SetItemString(d,"LOCALE_THOUSANDS_SEP", SWIG_From_int((int)(wxLOCALE_THOUSANDS_SEP)));
23944     }
23945     {
23946         PyDict_SetItemString(d,"LOCALE_DECIMAL_POINT", SWIG_From_int((int)(wxLOCALE_DECIMAL_POINT)));
23947     }
23948     {
23949         PyDict_SetItemString(d,"LOCALE_LOAD_DEFAULT", SWIG_From_int((int)(wxLOCALE_LOAD_DEFAULT)));
23950     }
23951     {
23952         PyDict_SetItemString(d,"LOCALE_CONV_ENCODING", SWIG_From_int((int)(wxLOCALE_CONV_ENCODING)));
23953     }
23954     {
23955         PyDict_SetItemString(d,"CONVERT_STRICT", SWIG_From_int((int)(wxCONVERT_STRICT)));
23956     }
23957     {
23958         PyDict_SetItemString(d,"CONVERT_SUBSTITUTE", SWIG_From_int((int)(wxCONVERT_SUBSTITUTE)));
23959     }
23960     {
23961         PyDict_SetItemString(d,"PLATFORM_CURRENT", SWIG_From_int((int)(wxPLATFORM_CURRENT)));
23962     }
23963     {
23964         PyDict_SetItemString(d,"PLATFORM_UNIX", SWIG_From_int((int)(wxPLATFORM_UNIX)));
23965     }
23966     {
23967         PyDict_SetItemString(d,"PLATFORM_WINDOWS", SWIG_From_int((int)(wxPLATFORM_WINDOWS)));
23968     }
23969     {
23970         PyDict_SetItemString(d,"PLATFORM_OS2", SWIG_From_int((int)(wxPLATFORM_OS2)));
23971     }
23972     {
23973         PyDict_SetItemString(d,"PLATFORM_MAC", SWIG_From_int((int)(wxPLATFORM_MAC)));
23974     }
23975     {
23976         PyDict_SetItemString(d,"BUFFER_VIRTUAL_AREA", SWIG_From_int((int)(wxBUFFER_VIRTUAL_AREA)));
23977     }
23978     {
23979         PyDict_SetItemString(d,"BUFFER_CLIENT_AREA", SWIG_From_int((int)(wxBUFFER_CLIENT_AREA)));
23980     }
23981     {
23982         PyDict_SetItemString(d,"IMAGELIST_DRAW_NORMAL", SWIG_From_int((int)(wxIMAGELIST_DRAW_NORMAL)));
23983     }
23984     {
23985         PyDict_SetItemString(d,"IMAGELIST_DRAW_TRANSPARENT", SWIG_From_int((int)(wxIMAGELIST_DRAW_TRANSPARENT)));
23986     }
23987     {
23988         PyDict_SetItemString(d,"IMAGELIST_DRAW_SELECTED", SWIG_From_int((int)(wxIMAGELIST_DRAW_SELECTED)));
23989     }
23990     {
23991         PyDict_SetItemString(d,"IMAGELIST_DRAW_FOCUSED", SWIG_From_int((int)(wxIMAGELIST_DRAW_FOCUSED)));
23992     }
23993     {
23994         PyDict_SetItemString(d,"IMAGE_LIST_NORMAL", SWIG_From_int((int)(wxIMAGE_LIST_NORMAL)));
23995     }
23996     {
23997         PyDict_SetItemString(d,"IMAGE_LIST_SMALL", SWIG_From_int((int)(wxIMAGE_LIST_SMALL)));
23998     }
23999     {
24000         PyDict_SetItemString(d,"IMAGE_LIST_STATE", SWIG_From_int((int)(wxIMAGE_LIST_STATE)));
24001     }
24002     PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
24003     SWIG_addvarlink(SWIG_globals,(char*)"NORMAL_FONT",_wrap_NORMAL_FONT_get, _wrap_NORMAL_FONT_set);
24004     SWIG_addvarlink(SWIG_globals,(char*)"SMALL_FONT",_wrap_SMALL_FONT_get, _wrap_SMALL_FONT_set);
24005     SWIG_addvarlink(SWIG_globals,(char*)"ITALIC_FONT",_wrap_ITALIC_FONT_get, _wrap_ITALIC_FONT_set);
24006     SWIG_addvarlink(SWIG_globals,(char*)"SWISS_FONT",_wrap_SWISS_FONT_get, _wrap_SWISS_FONT_set);
24007     SWIG_addvarlink(SWIG_globals,(char*)"RED_PEN",_wrap_RED_PEN_get, _wrap_RED_PEN_set);
24008     SWIG_addvarlink(SWIG_globals,(char*)"CYAN_PEN",_wrap_CYAN_PEN_get, _wrap_CYAN_PEN_set);
24009     SWIG_addvarlink(SWIG_globals,(char*)"GREEN_PEN",_wrap_GREEN_PEN_get, _wrap_GREEN_PEN_set);
24010     SWIG_addvarlink(SWIG_globals,(char*)"BLACK_PEN",_wrap_BLACK_PEN_get, _wrap_BLACK_PEN_set);
24011     SWIG_addvarlink(SWIG_globals,(char*)"WHITE_PEN",_wrap_WHITE_PEN_get, _wrap_WHITE_PEN_set);
24012     SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_PEN",_wrap_TRANSPARENT_PEN_get, _wrap_TRANSPARENT_PEN_set);
24013     SWIG_addvarlink(SWIG_globals,(char*)"BLACK_DASHED_PEN",_wrap_BLACK_DASHED_PEN_get, _wrap_BLACK_DASHED_PEN_set);
24014     SWIG_addvarlink(SWIG_globals,(char*)"GREY_PEN",_wrap_GREY_PEN_get, _wrap_GREY_PEN_set);
24015     SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_PEN",_wrap_MEDIUM_GREY_PEN_get, _wrap_MEDIUM_GREY_PEN_set);
24016     SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_PEN",_wrap_LIGHT_GREY_PEN_get, _wrap_LIGHT_GREY_PEN_set);
24017     SWIG_addvarlink(SWIG_globals,(char*)"BLUE_BRUSH",_wrap_BLUE_BRUSH_get, _wrap_BLUE_BRUSH_set);
24018     SWIG_addvarlink(SWIG_globals,(char*)"GREEN_BRUSH",_wrap_GREEN_BRUSH_get, _wrap_GREEN_BRUSH_set);
24019     SWIG_addvarlink(SWIG_globals,(char*)"WHITE_BRUSH",_wrap_WHITE_BRUSH_get, _wrap_WHITE_BRUSH_set);
24020     SWIG_addvarlink(SWIG_globals,(char*)"BLACK_BRUSH",_wrap_BLACK_BRUSH_get, _wrap_BLACK_BRUSH_set);
24021     SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_BRUSH",_wrap_TRANSPARENT_BRUSH_get, _wrap_TRANSPARENT_BRUSH_set);
24022     SWIG_addvarlink(SWIG_globals,(char*)"CYAN_BRUSH",_wrap_CYAN_BRUSH_get, _wrap_CYAN_BRUSH_set);
24023     SWIG_addvarlink(SWIG_globals,(char*)"RED_BRUSH",_wrap_RED_BRUSH_get, _wrap_RED_BRUSH_set);
24024     SWIG_addvarlink(SWIG_globals,(char*)"GREY_BRUSH",_wrap_GREY_BRUSH_get, _wrap_GREY_BRUSH_set);
24025     SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_BRUSH",_wrap_MEDIUM_GREY_BRUSH_get, _wrap_MEDIUM_GREY_BRUSH_set);
24026     SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_BRUSH",_wrap_LIGHT_GREY_BRUSH_get, _wrap_LIGHT_GREY_BRUSH_set);
24027     SWIG_addvarlink(SWIG_globals,(char*)"BLACK",_wrap_BLACK_get, _wrap_BLACK_set);
24028     SWIG_addvarlink(SWIG_globals,(char*)"WHITE",_wrap_WHITE_get, _wrap_WHITE_set);
24029     SWIG_addvarlink(SWIG_globals,(char*)"RED",_wrap_RED_get, _wrap_RED_set);
24030     SWIG_addvarlink(SWIG_globals,(char*)"BLUE",_wrap_BLUE_get, _wrap_BLUE_set);
24031     SWIG_addvarlink(SWIG_globals,(char*)"GREEN",_wrap_GREEN_get, _wrap_GREEN_set);
24032     SWIG_addvarlink(SWIG_globals,(char*)"CYAN",_wrap_CYAN_get, _wrap_CYAN_set);
24033     SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY",_wrap_LIGHT_GREY_get, _wrap_LIGHT_GREY_set);
24034     SWIG_addvarlink(SWIG_globals,(char*)"STANDARD_CURSOR",_wrap_STANDARD_CURSOR_get, _wrap_STANDARD_CURSOR_set);
24035     SWIG_addvarlink(SWIG_globals,(char*)"HOURGLASS_CURSOR",_wrap_HOURGLASS_CURSOR_get, _wrap_HOURGLASS_CURSOR_set);
24036     SWIG_addvarlink(SWIG_globals,(char*)"CROSS_CURSOR",_wrap_CROSS_CURSOR_get, _wrap_CROSS_CURSOR_set);
24037     SWIG_addvarlink(SWIG_globals,(char*)"NullBitmap",_wrap_NullBitmap_get, _wrap_NullBitmap_set);
24038     SWIG_addvarlink(SWIG_globals,(char*)"NullIcon",_wrap_NullIcon_get, _wrap_NullIcon_set);
24039     SWIG_addvarlink(SWIG_globals,(char*)"NullCursor",_wrap_NullCursor_get, _wrap_NullCursor_set);
24040     SWIG_addvarlink(SWIG_globals,(char*)"NullPen",_wrap_NullPen_get, _wrap_NullPen_set);
24041     SWIG_addvarlink(SWIG_globals,(char*)"NullBrush",_wrap_NullBrush_get, _wrap_NullBrush_set);
24042     SWIG_addvarlink(SWIG_globals,(char*)"NullPalette",_wrap_NullPalette_get, _wrap_NullPalette_set);
24043     SWIG_addvarlink(SWIG_globals,(char*)"NullFont",_wrap_NullFont_get, _wrap_NullFont_set);
24044     SWIG_addvarlink(SWIG_globals,(char*)"NullColour",_wrap_NullColour_get, _wrap_NullColour_set);
24045     SWIG_addvarlink(SWIG_globals,(char*)"TheFontList",_wrap_TheFontList_get, _wrap_TheFontList_set);
24046     SWIG_addvarlink(SWIG_globals,(char*)"ThePenList",_wrap_ThePenList_get, _wrap_ThePenList_set);
24047     SWIG_addvarlink(SWIG_globals,(char*)"TheBrushList",_wrap_TheBrushList_get, _wrap_TheBrushList_set);
24048     SWIG_addvarlink(SWIG_globals,(char*)"TheColourDatabase",_wrap_TheColourDatabase_get, _wrap_TheColourDatabase_set);
24049
24050     // Work around a chicken/egg problem in drawlist.cpp
24051     wxPyDrawList_SetAPIPtr();
24052
24053 }
24054